Question

我试图创建一个固定大小的自己的列表类，并且可以存储整数。仅用于学习目的。

我就是这样做的：我有一个名为Item的结构，它保存数据（要存储的整数），以及指向列表中下一个项目的指针。当列表初始化时，我首先将x个空项添加到列表中。

迭代（n-1）中声明的项的地址存储在缓冲区中，因此迭代n中项的地址可以设置为上一次迭代（n-1）中项的下一个。这可以将所有物品相互链接。

第一个项目的地址也被保存，作为代码中稍后整个列表的访问点。

但它并没有真正发挥作用;这是我的代码：

#include <iostream>

class List {
    public:
    //Item-object needed to store
    //elements
    struct Item {
        int data = 0;
        Item* next = nullptr;
    };

    //Constructor
    //creates a list of fixed size
    List(int size) {
        //Filling up with empty items
        for (int i = 0; i < size; i++) {
            Item item;

            //Storing iterator in item (just for testing purposes)
            item.data = i;

            //If first item,
            //store start-address
            //set buffer to start address
            if (i == 0) 
                this->start = &item;

            //Setting current item as nextptr
            //for previous item in buffer 
            if (i > 0)
                this->buffer->next = &item;

            //Storing current address in buffer
            this->buffer = &item;

            //Outputting address and value (just for testing purposes)
            //std::cout << "Address: " << &item << " -> " << item.data << std::endl;
        }
    }

    Item* getFirstItemAddress() {
        return this->start;
    }

    private:
    //Holding address of first item
    Item* start = nullptr;

    //Buffer holding temporary address
    Item* buffer = nullptr;

};

int main() {
    List list(5);

    //Printing out
    List::Item* current = list.getFirstItemAddress();
    while (current->next) {
        std::cout << current->data << std::endl;
        current = current->next;
    }

    return 0;
}

这是输出：

Testing output:
1168769696
-1064971727
Segmentation fault

然而，当我取消测试第37行时，这是输出：

Address: 0x7ffe54015cf0 -> 0
Address: 0x7ffe54015cf0 -> 1
Address: 0x7ffe54015cf0 -> 2
Address: 0x7ffe54015cf0 -> 3
Address: 0x7ffe54015cf0 -> 4

Testing output:
1648675776
1648572376
1646105840
1226279756
Segmentation fault

我首先不了解输出如何改变“测试输出”的输出。这非常......

无论如何，分段错误信息：

(gdb) run
Starting program: /home/niel/Desktop/listTest/main 
Address: 0x7fffffffe0a0 -> 0
Address: 0x7fffffffe0a0 -> 1
Address: 0x7fffffffe0a0 -> 2
Address: 0x7fffffffe0a0 -> 3
Address: 0x7fffffffe0a0 -> 4

Testing output:
-136467520
-136570920
-139037456
1226279756

Program received signal SIGSEGV, Segmentation fault.
0x000000000040092e in main () at main.cpp:62
62              std::cout << current->data << std::endl;

不知道为什么current-＆gt;数据给出了分段错误，因为我给每个元素提供了数据！

但最困扰我的是：

 Address: 0x7fffffffe0a0 -> 0
    Address: 0x7fffffffe0a0 -> 1
    Address: 0x7fffffffe0a0 -> 2
    Address: 0x7fffffffe0a0 -> 3
    Address: 0x7fffffffe0a0 -> 4

每个项目都有相同的地址，当然，这不是我的意思。在迭代中创建的每个项目应该是具有另一个地址的另一个项目。这与Item被声明为本地有什么关系，因为该原因的对象存储在堆栈而不是自由空间？我尝试使用＆＃39; new＆＃39;关键字，但那不起作用！

TL; DR 1）为什么我得到分段错误 2）如何修复List（）中创建的每个项目都有一个单独的地址？

Answer 1

问题

在列表构造函数中，在列表中放入对象item的地址，该对象是循环的本地对象，并在每次迭代结束时被销毁。

解决方案

您必须在免费商店中创建一个new对象，以便它能够在迭代和构造函数结束时存活下来。在你学习的过程中，我保持简单并使用原始指针：

List(int size) {
    for (int i = 0; i < size; i++) {
        Item *pitem = new Item;  
        pitem->data = i;  

        if (i == 0) 
            start = pitem;
        if (i > 0)
            buffer->next = pitem;

        //Storing current address in buffer
        buffer = pitem;

        //Outputting address and value (just for testing purposes)
        //std::cout << "Address: " << pitem << " -> " << item->data << std::endl;
    }
}

但是你的代码会泄漏内存。如果你有这样的构造函数，你还需要一个复制构造函数，赋值运算符和析构函数（rule of 3）

Answer 2

Item item;是一个堆栈分配变量，这意味着当程序退出当前作用域（在本例中为一个for循环迭代）时，它将被释放。内存地址是相同的，因为编译器每次都在同一位置分配它。您的程序崩溃是因为您尝试取消引用指向任何内容的指针。

你应该通过Item在堆上动态分配每个new Item; - 但要小心，你必须在每一个上调用delete你分配的变量，否则你自己会发生内存泄漏。

在for循环中创建的对象具有相同的地址

2 个答案: