数组结构

Question

我正在尝试制作一个小的自定义向量...

元素类，应该指向下一个类的地址，但是使用此代码

class foo {
private:
    int attr;
public:
    foo(){attr = 10;}
    int get_attr(){return attr;}
    void set_attr(int a){attr =a;}
};

class element_foo {
private:
    foo data;
    element_foo *ptr_next;
public:
    element_foo(){ptr_next = NULL;}
    element_foo(int dat){data.set_attr(dat); ptr_next = NULL;}
    element_foo(int dat, element_foo next){
        data.set_attr(dat);
        ptr_next = &next;
    }
    foo get_data(){return data;}

    element_foo get_next(){return *ptr_next;}

    void print_array(){
        if (ptr_next == NULL) {
            std::cout<< data.get_attr()<<std::endl;
        }
        else {
            std::cout<< data.get_attr()<<std::endl;
            this->get_next().print_array();
        }

    }
};



int main (int argc, char * const argv[]) {
    // insert code here...  
    element_foo a1(10);
    element_foo a2(15,a1);
    element_foo a3(20,a2);

    a3.print_array();

    std::cout << "Hello, World!\n";
    return 0;
}

，当我打印 a3 时，它会出现分段错误...为什么？我的错误在哪里？

Answer 1

错误出现在这个构造函数中：

element_foo(int dat, element_foo next){
    data.set_attr(dat);
    ptr_next = &next;
}

您正在获取本地地址。 ptr_next = &next; 一旦函数结束，地址就无效。

您需要做的是将 next 作为指针传递：

element_foo(int dat, element_foo *next){
    data.set_attr(dat);
    ptr_next = next;
}

并将 main 更改为：

element_foo a1(10);
element_foo a2(15,&a1);
element_foo a3(20,&a2);

编辑：

或者，您可以通过引用传递它：

element_foo(int dat, element_foo &next){
    data.set_attr(dat);
    ptr_next = &next;
}

Answer 2

问题是您正在存储指向临时对象的指针。

'next' 只是您传入的 a1/a2 的副本，因为按值复制。您应该使用按引用复制，以便 &next 准确引用 a1/a2 的地址，而不是它们的副本。

                     v-------- should use "const element_foo &"
element_foo(int dat, element_foo next){
        data.set_attr(dat);
        ptr_next = &next;
    }

// a2->ptr_next is dangling
element_foo a2(15,a1);

当上面这行执行时，a2->ptr_next并没有指向a1，
而是一个已经被破坏的临时本地对象。
因此a2->ptr_next是悬空的。以后通过该指针进行的任何访问都具有未定义的行为。