Question

我正在学习c ++课程，所以我尝试了不同的东西来适应课程。在这里，我试图传递一个指向类函数的指针：

class Pointerss{
    int size;
public:
    Pointerss(int);
    void f();
    int *a;
};

Pointerss::Pointerss(int siz){
    size = siz;
}

void Pointerss::f(){
    cout<<"Size is:"<<size<<"\n";
    for (int i=0; i<size; ++i) {
       cout<<"a is:"<<a[i]<<"\n";
    }
}
int main() {
    int size = 5;
    Pointerss dd (size);
    Pointerss * p = new Pointerss(size);
    p[0]=1; p[1]=2; p[2]=3; p[3]=4; p[4]=5;
    p->a;
    dd.f();
    return 0;

}

因此“size”由构造函数初始化，当调用“f（）”时，将打印正确的数字。但是当我将“p”分配给“a”（“p-＆gt; a”）然后调用“f（）”时，会打印一些随机数。我的电脑打印出来：

Size is:5
a is:0
a is:0
a is:1
a is:0
a is:1606416856
Program ended with exit code: 0

“a”和“size”之间的区别是什么？如何将指针传递给函数？

Answer 1

打印随机数是因为您从未初始化的Pointerss::f解除引用dd.a。取消引用未初始化的指针会导致未定义的行为。

这不是你唯一的错误。您还为单个Pointerss对象分配内存，该对象由p指向，但随后继续在p[1..4]中构造指向未分配内存的对象。这也会导致不确定的行为。

第三，您永远不会释放您使用new分配的内存。

Answer 2

第1步是理解指针。当你创建int*时，你只保留内存来存储指针本身。你不为任何int保留记忆。因此，当您尝试打印整数时，您只能得到随机数（或者程序崩溃）。

所以你的班级不能持有任何整数。您需要更改它，以便在构造函数中保留内存并在析构函数中释放它。

class Pointerss{
    int size;
public:
    Pointerss(int);
    ~Pointerss();
    void f();
    int *a;
};

Pointerss::Pointerss(int siz){
    size = siz;
    a = new int[size];  // Reserve memory for size integers

    // Do some initialization if needed, e.g.
    for (int i=0; i < size; i++) a[i] = i;
}

Pointerss::~Pointerss(){
    delete[] a;         // Release the memory again
}

void Pointerss::f(){
    cout<<"Size is:"<<size<<"\n";
    for (int i=0; i<size; ++i) {
       cout<<"a is:"<<a[i]<<"\n";
    }
}

此外，您无法制作指向该类实例的单个指针，即

Pointerss * p = new Pointerss(size);

然后像

一样使用它

p[0]=1; p[1]=2; p[2]=3; p[3]=4; p[4]=5;

因为它在5个不同的实例上运行。

最后代码：

p->a;

什么都不做！

你可以做到

p->a[0] = 5;

但目前还不清楚你要做什么。

请注意，dd和p引用了类的两个不同实例，因此更改*p内的某些内容根本不会更改dd。

如果你做了：

Pointerss *p = &dd;

然后*p和dd将是同一个实例。

将指针传递给c ++中的类函数

2 个答案: