Question

我创建了一个类对象的向量。以下程序与

崩溃

 "Pointer being freed was not allocated".

我也有很深的复制。我没有看到双重删除发生在哪里。我错过了什么？。

    #include <iostream>
    #include <vector>
    using namespace std;

    enum MessageType { HEADER, DATA, CLOSE};

    typedef class bufferElement{

    public:
        char *buffer ; //The actual data
        int64_t length; //length of the data
        MessageType messagetype;    

        /**
         * Copy constructor for the structure
         */
        bufferElement(const struct bufferElement &toCopy)
        {
            std::cout << "Copying the buffer vector - Copy Constructor for buffer" << std::endl;
            buffer = new char[toCopy.length];
            memcpy(buffer,toCopy.buffer,toCopy.length);
            length = toCopy.length;
            messagetype = toCopy.messagetype;
        }


        bufferElement()
        {
            buffer = NULL;
            length =0;
            messagetype = HEADER;
        }

        /**
         *  Initialises the vector element
         *  @param messagetype
         *  what type of message is the particular element.
         *  @param element
         *  The buffer element
         *  @param length_t
         *  The length/size of the buffer element
         */
        bufferElement(char *element, int64_t length_t, MessageType messagetype_t)   //constructor
        {
            std::cout << "The buffer element is Initialized" << std::endl;
            buffer = new char[length_t];
            messagetype = messagetype_t;
            length = length_t;
            memcpy(buffer, element, length_t);
        }

        ~bufferElement()
        {
            std::cout << "Freeing the buffer in the vector - Destructor" << std::endl;
            delete buffer;
            buffer = NULL;
        }


    } messageHolder;

    int main()
    {
        vector<messageHolder> v;
        for(int64_t i=0; i< 1000000000000000000; i++)
        {
            int size = rand()%10000+5;
            char *test = new char[size];
            messageHolder m(test, size, HEADER );
            v.push_back(m);

            if(rand()%3)
            {
                v.erase(v.begin());
            }

        }

        return 0;
    }

Answer 1

我没有详细查看过您的代码，但如果您认为需要复制构造函数，则还需要一个赋值运算符。而且，为什么，为什么，为什么要写这些东西呢？为什么不使用std :: string？你觉得有必要编写自己的浮点类型吗？不，我不这么认为。

Answer 2

使用delete[]代替delete，因为您正在释放数组。

顺便说一下，在main()中，您还应该调用delete[] test;，否则，您将收到内存泄漏。

Answer 3

一般情况下，我会避免使用带指针的对象（如bufferElement中的缓冲区）作为vector（或任何其他stl容器）中的类型，而不使用复制构造函数和赋值运算符。如果析构函数释放了指针，那么它就是破坏的秘诀。你应该打架 a）提供复制ctr和分配op

或

b）不要使用指针（使用像boost :: scoped_ptr或boost：shared_ptr这样的智能指针，甚至在你的情况下使用auto_ptr）我更喜欢

类对象传染媒介

3 个答案: