javascript

java

python

c#

android

node.js

c++

reactjs

php

html

jquery

css

.net

ios

git

ruby-on-rails

sql

c

string

ruby

二维数组的指针

我对2D数组的指针有疑问。 如果数组像

int a[2][3];

那么,这是指向数组[3]的指针吗?

int (*p)[3] = a;

如果是正确的话,我想知道[3]int(*p)[3]意味着什么?

trans by 2020-02-22T05:34:19Z

c-释放指针后,是否应该将指针真正设置为“ NULL”?

似乎有两个争论,为什么一个人在释放它们后应该设置一个指向NULL的指针。

避免在两次释放指针时崩溃。

简介:设置为someStruct->lastMember时,意外地第二次致电NULL不会崩溃。

  • 几乎总是掩盖一个逻辑错误,因为没有理由第二次致电NULL。 让应用程序崩溃并能够对其进行修复是更安全的。

  • 它不能保证会崩溃,因为有时会在同一地址分配新的内存。

  • 当有两个指针指向同一地址时,通常会发生双重释放。

逻辑错误也可能导致数据损坏。

避免重用释放的指针

简短说明:如果NULL在同一位置分配内存,则访问释放的指针可能导致数据损坏,除非将释放的指针设置为someStruct->lastMember

  • 如果偏移量足够大(someStruct->lastMembertheArray[someBigNumber]),则无法保证程序在访问NULL指针时崩溃。 不会崩溃,不会有数据损坏。

  • 将指针设置为NULL不能解决具有相同指针值的其他指针的问题。

问题

这是一个有关释放后盲目将指针设置为NULL的帖子。

  • 哪一个更难调试?
  • 有可能两者兼得吗?
  • 这些错误导致数据损坏而不是崩溃的可能性有多大?

随意扩展这个问题。

trans by 2020-02-22T04:19:16Z

指针-C ++中的声明

据我了解,C ++中的声明/初始化是带有“基本类型”的语句,后跟逗号分隔的声明符列表。

请考虑以下声明:

int i = 0, *const p = &i; // Legal, the so-called base type is 'int'.
                          // i is an int while p is a const pointer to an int.

int j = 0, const c = 2;   // Error: C++ requires a type specifier for all declarations.
                          // Intention was to declare j as an int and c an as const int.

int *const p1 = nullptr, i1 = 0; // p1 is a const pointer to an int while i1 is just an int.

int const j1 = 0, c1 = 2;   // Both j1 and c1 are const int.

2758082748895200200256是基本类型还是复合类型?

从上面第二个声明中的错误来看,它似乎是基本类型。 如果是这样,那么第一个声明呢?

换句话说,如果第一个陈述是合法的,为什么第二个陈述不合法? 此外,为什么第三和第四条语句的行为有所不同?

trans by 2020-02-22T00:44:25Z

c-远指针和近指针有什么区别?

有人可以告诉我C中的far指针和near指针之间的区别吗?

trans by 2020-02-20T01:10:14Z

C ++-gsl :: not_null <T *>与std :: reference_wrapper <T>与T&

最近已经发布了C ++核心准则(恭喜!),我担心cpp-core-guidelines类型。 如I.12中所述:声明一个不能为null的指针,如cpp-core-guidelines

为了避免避免取消引用nullptr错误。 通过提高性能   避免对nullptr进行冗余检查。

...

通过说明意图   源,实施者和工具可以提供更好的诊断,例如   通过静态分析发现一些错误类别,并执行   优化,例如删除分支和空测试。

目的很明确。 但是,我们已经为此提供了语言功能。 不能为空的指针称为引用。 并且尽管引用一旦创建便无法反弹,但此问题已由cpp-core-guidelines解决。

我看到的cpp-core-guidelinesguideline-support-library之间的主要区别在于,后者只能代替指针使用,而前者可以处理任何string_view-assignable(引用自F.17:使用not_null表示“ null”无效) 值):

cpp-core-guidelines不仅适用于内置指针。 它适用于   guideline-support-librarystring_viewunique_ptrshared_ptr等   指针式类型。

我想象功能比较表如下:

cpp-core-guidelines

  • 无法存储cpp-core-guidelines? -是的
  • 可重新绑定? -没有
  • 可以用来代替指针吗? -没有

cpp-core-guidelines

  • 无法存储cpp-core-guidelines? -是的
  • 可重新绑定? -是的
  • 可以用来代替指针吗? -没有

cpp-core-guidelines

  • 无法存储cpp-core-guidelines? -是的
  • 可重新绑定? -是的
  • 可以用来代替指针吗? -是的

现在终于有了问题了:

  1. 我对这些概念之间的差异的理解正确吗?
  2. 这是否意味着cpp-core-guidelines现在无用了?

PS我为此创建了标签cpp-core-guidelinesguideline-support-library,我希望正确。

trans by 2020-02-18T20:23:53Z

通过从本地C样式数组返回指针来获得悬空指针

我对以下代码有些困惑:

#include <iostream>

const char* f()
{
    const char* arr[]={"test"};
    return arr[0];
}

int main()
{
    auto x = f();
    std::cout << x;
}

我认为此代码应为UB(未定义的行为)。 我们返回一个指向本地作用域内的C样式数组元素的指针。 事情应该出错。 但是,我测试过的编译器都没有抱怨(我在g ++和clang上都使用了-Wall -Wextra -pedantic)。 valgrind也没有抱怨。

上面的代码有效吗?还是像人们想的那样是UB?

PS:运行它似乎会产生“正确”的结果,即显示“测试”,但这并不表示正确。

trans by 2020-02-17T12:56:42Z

如何使用指针从其他函数访问局部变量?

我可以在其他函数中访问局部变量吗? 如果是这样,怎么办?

void replaceNumberAndPrint(int array[3]) {
    printf("%i\n", array[1]);
    printf("%i\n", array[1]);
}

int * getArray() {
    int myArray[3] = {4, 65, 23};
    return myArray;
}

int main() {
    replaceNumberAndPrint(getArray());
}

上面这段代码的输出:

65
4202656

我究竟做错了什么? “ 4202656”是什么意思?

我是否必须复制replaceNumberAndPrint()函数中的整个数组才能获得比第一次更多的访问权限?

trans by 2020-02-13T02:47:36Z

目标C - 为什么[对象DoSomething的]而不是[*对象DoSomething的]?

在Objective-C中,为什么要[object doSomething]?那岂不是[*object doSomething]因为你调用对象?,这意味着你应该取消引用指针上的方法?

trans by 2020-02-12T21:16:48Z

指针-Box,ref和&和*之间的理解和关系

我对指针在Rust中的工作方式有些困惑。 有*let y: i32 = 4; let x = &y as *const i32**,但我不确定它们如何协同工作。

这是我目前的理解:

  1. *并不是真正的指针-这是一种在堆上分配数据并在函数参数中传递大小不一的类型(尤其是特征)的方法。
  2. *用于模式匹配,以借用您匹配的内容,而不是采用它。 例如,

    *
  3. *用于借入(借入的指针)。 如果我有一个函数let y: i32 = 4; let x = &y as *const i32,那么我引用的是我自己,该函数将在函数终止后到期,而不再保留调用者的数据。 通过执行*,我还可以传递要保留所有权的数据。

  4. *用于制作原始指针:例如let y: i32 = 4; let x = &y as *const i32。我了解C / C ++中的指针,但不确定如何将其与Rust的类型系统一起使用以及如何安全使用它们。 我也不确定这种指针的用例是什么。 此外,*符号可用于取消引用事物(什么事物,为什么?)。

有人可以解释指向我的第四种指针,并验证我对其他类型的理解是否正确吗? 我还要感谢任何指出我没有提到的常见用例的人。

trans by 2020-02-09T13:00:26Z

c-漏洞利用代码中的指针说明

在一些获取根shell的漏洞中,我经常看到这样的指针:

int i;
unsigned *p = *(unsigned**)(((unsigned long)&i) & ~8191); 

谁能解释一下这个指针? 我认为8191是内核堆栈的大小。 p是否指向内核堆栈的底部?这是使用指针p的方式:

int i; 
unsigned *p = *(unsigned**)(((unsigned long)&i) & ~8191); 
for (i = 0; i < 1024-13; i++) { 
    if (p[0] == uid && p[1] == uid && 
        p[2] == uid && p[3] == uid && 
        p[4] == gid && p[5] == gid && 
        p[6] == gid && p[7] == gid) { 
            p[0] = p[1] = p[2] = p[3] = 0; 
            p[4] = p[5] = p[6] = p[7] = 0; 
            p = (unsigned *) ((char *)(p + 8) + sizeof(void *)); 
            p[0] = p[1] = p[2] = ~0; 
            break; 
        } 
    p++; 
} 
trans by 2020-02-08T22:55:12Z

如何修改已传递到C函数中的指针?

因此,我有一些类似于以下内容的代码,用于将结构添加到结构列表中:

void barPush(BarList * list,Bar * bar)
{
    // if there is no move to add, then we are done
    if (bar == NULL) return;//EMPTY_LIST;

    // allocate space for the new node
    BarList * newNode = malloc(sizeof(BarList));

    // assign the right values
    newNode->val = bar;
    newNode->nextBar = list;

    // and set list to be equal to the new head of the list
    list = newNode; // This line works, but list only changes inside of this function
}

这些结构定义如下:

typedef struct Bar
{
    // this isn't too important
} Bar;

#define EMPTY_LIST NULL

typedef struct BarList
{
    Bar * val;
    struct  BarList * nextBar;
} BarList;

然后在另一个文件中,执行以下操作:

BarList * l;

l = EMPTY_LIST;
barPush(l,&b1); // b1 and b2 are just Bar's
barPush(l,&b2);

但是,此后,我仍然指向EMPTY_LIST,而不是在barPush内部创建的修改版本。 如果要修改列表,是否必须将列表作为指针传递给指针,还是需要其他暗咒语?

trans by 2020-02-07T14:18:29Z

c ++-此错误是什么意思:“错误:'type_name'之前的预期specifier-qualifier-list”?

我一直在研究Cell处理器,正在尝试创建一个结构,该结构将容纳spe_context_ptr_t,该结构将在线程内用于启动spe上下文,还将保留指向将传递给其他对象的指针。 线程内部的spu上下文(当前,我试图使其成为通用指针,但实际上,它将是指向我定义的另一种结构的指针)。 尝试编译时,出现以下错误:

spu/../common.h:38: error: expected specifier-qualifier-list before 'spe_context_ptr_t'

// here is the offending line(s)

typedef struct _PTHREAD_BLOCK {
    spe_context_ptr_t * context; // Error happens here
    uintptr32_t  args; 
 } PTHREAD_BLOCK;
trans by 2020-02-06T09:21:07Z

c-如何检查char *变量是否指向空字符串?

如何检查char*变量是否指向空字符串?

trans by 2020-02-06T03:27:41Z

c ++-使用boost :: shared_ptr有哪些潜在危险?

使用boost::shared_ptr时,有哪些方法可以使自己脚部射击? 换句话说,使用boost::shared_ptr时必须避免什么陷阱?

trans by 2020-02-04T03:53:15Z

C ++-只写指针类型

我正在为嵌入式系统编写软件。

我们使用指针来访问FPGA器件的寄存器。
一些寄存器是只读的,而另一些是只写的。

只读寄存器在读取时将产生未定义的值。

我想定义一个指针类型,该类型将允许编译器检测何时从只写寄存器中读取值(也称为解引用)。

只能使用C语言语法创建只写指针吗?
(我们正在使用C开发第一个原型,但是在第二代移植到C ++。)

如何在C ++中创建有效的只写指针?(请记住,这不是跟踪动态内存中的项目,而是访问硬件地址。)

此代码用于安全性和质量最受关注的嵌入式系统。

trans by 2020-02-03T22:16:54Z

带有两个不同缓冲区的指针算术

考虑以下代码:

int* p1 = new int[100];
int* p2 = new int[100];
const ptrdiff_t ptrDiff = p1 - p2;

int* p1_42 = &(p1[42]);
int* p2_42 = p1_42 + ptrDiff;

现在,标准是否保证p2_42指向p2[42]? 如果不是,在Windows,Linux或Webassembly堆上是否总是如此?

trans by 2020-02-02T21:52:26Z

删除之前是否有任何理由检查NULL指针?

我经常看到遗留代码在删除指针之前先检查NULL,类似于,

if (NULL != pSomeObject) 
{
    delete pSomeObject;
    pSomeObject = NULL;
}

在删除指针之前,是否有任何理由要检查NULL指针? 之后将指针设置为NULL的原因是什么?

trans by 2020-02-02T06:01:19Z

c-NULL是否始终为假?

是否可以安全地假设NULL在C中始终转换为false?

void *somePtr = NULL;

if (!somePtr) {
  /* This will always be executed? */
}

还是应该对NULL的值进行明确检查?

trans by 2020-02-01T13:09:03Z

c-取数组地址时的不同指针算术结果

程序:

#include<stdio.h>

int main(void) {
    int x[4];
    printf("%p\n", x);
    printf("%p\n", x + 1);
    printf("%p\n", &x);
    printf("%p\n", &x + 1);
}

输出:

$ ./a.out
0xbff93510
0xbff93514
0xbff93510
0xbff93520
$

我希望以下是上述程序的输出。 例如:

x        // 0x100
x+1      // 0x104  Because x is an integer array
&x       // 0x100  Address of array
&x+1     // 0x104

但是最后一条语句的输出与我期望的不同。 &x也是阵列的地址。 因此,对此增加1将打印递增4的地址。但是&x+1给出递增10的地址。为什么?

trans by 2020-02-01T11:44:04Z

C ++-不允许指向不完整类类型的指针

由于某些原因,我无法使用附加到要使用的对象的函数。 我在行中添加了注释。 作为错误,我收到“错误;不允许指向不完整类类型的指针”请帮助

这是dokter.ccp中的代码

int counter = 0;        
for (list<Wielrenner*>::iterator it = wielrenners.begin(); it != wielrenners.end(); it++){
    Wielrenner* wielrennerOB = *it;
    cout << "\nID: " << counter;
    cout << "List size: " << persons.size() << endl;

    wielrennerOB->print();  // This is not working
    counter++;
 }  

这是wielrenner.h中的代码

#ifndef WIELRENNER_H_

#define WIELRENNER_H_

//#include <fstream>

#include "persoon.h"

#include "Onderzoek.h"

class Wielrenner :
public Persoon
{
public:
    Wielrenner(string, string, Adres, string, Datum, Datum, string, int, float, float, float,list<Onderzoek>* );
    ~Wielrenner(void);
    int     getLengte() const;
    float   getGewicht() const;
    float   getVo2max() const;
    float   getMaxVermogen() const;
    list<Onderzoek> getOnderzoekenList();

    void    setLengte(int);
    void    setGewicht(float);
    void    setVo2max(float);
    void    setMaxVermogen(float);
    void    voegOnderzoekToeList(Onderzoek);
    void    showOnderzoeksList();
    void    setOnderzoeksLijst(list<Onderzoek>&);
    void    print();
    void    printFile(ofstream&);


private:
int     lengte;
float   gewicht;
float   vo2max;
float   maxVermogen;
list<Onderzoek> onderzoeken;
};

#endif /* WIELRENNER_H_ */

wielrenner.CCP中的代码

using namespace std;
#include <string>

#include "Wielrenner.h"
/*
#include "Onderzoek.h"

*/
Wielrenner::Wielrenner(string voornaam, string achternaam, Adres adres, string telefoon, Datum datumInDienst, Datum geboorteDatum, 
                    string persoonType, int lengte, float gewicht, float vo2max, float maxVermogen,list<Onderzoek>* onderzoeken)
        : lengte(lengte), 
    gewicht(gewicht), 
    vo2max(vo2max), 
    maxVermogen(maxVermogen),
    Persoon(voornaam, achternaam, adres, telefoon, datumInDienst, geboorteDatum, persoonType)
{
}


Wielrenner::~Wielrenner(void)
{
}

//setten van gegevens
void    Wielrenner::setLengte(int newLengte){
lengte = newLengte;
}
void    Wielrenner::setGewicht(float newGewicht){
gewicht = newGewicht;
}
void    Wielrenner::setVo2max(float newVo2max){
vo2max = newVo2max;
}
void    Wielrenner::setMaxVermogen(float newMaxVermogen){
maxVermogen = newMaxVermogen;
}
void    Wielrenner::voegOnderzoekToeList(Onderzoek newOnderzoek){
onderzoeken.push_back(newOnderzoek);            
}

void    Wielrenner::showOnderzoeksList(){
int teller=0;

for (list<Onderzoek>::iterator it = onderzoeken.begin(); it != onderzoeken.end();     it++){
    Onderzoek onderzoekOB = *it;
    cout << teller << " - ";
    onderzoekOB.print();
    teller++;
 }  
}

void    Wielrenner::setOnderzoeksLijst(list<Onderzoek>& newOnderzoeksLijst){
onderzoeken = newOnderzoeksLijst;
}

void    Wielrenner::print(){

cout << "(" << persoonID << ") Persoon: " << endl;
cout << persoonType << endl;
cout << voornaam << " " << achternaam << endl;
adres.print();
cout << telefoon << endl;
cout << "Datum in dienst: ";
datumInDienst.print();
cout << "Geboortedatum: ";
geboorteDatum.print();
cout << "> Extra wielrenner gegevens: " << endl;
cout << "Lengte: " << lengte << endl;
cout << "Gewicht: " << gewicht << endl;
cout << "vo2max: " << vo2max << endl;
cout << "maxVermogen: " << maxVermogen << endl;
}
void Wielrenner::printFile(ofstream &myfile){

myfile <<  persoonID << "\n";
myfile << persoonType << "\n";
myfile << voornaam << " " << achternaam << "\n";
adres.printFile(myfile);
myfile << telefoon << "\n";
datumInDienst.printFile(myfile);
geboorteDatum.printFile(myfile);
myfile << lengte << "\n";
myfile << gewicht << "\n";
myfile << vo2max << "\n";
myfile << maxVermogen << "\n";
}
// returnen van gegevens

int     Wielrenner::getLengte() const{
return lengte;
}
float   Wielrenner::getGewicht() const{
return gewicht;
}
float   Wielrenner::getVo2max() const{
return vo2max;
}   
float   Wielrenner::getMaxVermogen() const{
return maxVermogen;
}
list<Onderzoek> Wielrenner::getOnderzoekenList(){
return onderzoeken;
}
trans by 2020-01-30T07:21:19Z

1 2 3 4 5 6 7 8 9 10 下一页 共10页