C ++复制指针指向的数据

Question

I'm a long-time reader, and first-time poster... I've searched long and hard to find an answer to something that's really boggling my mind right now. I must be missing something, as I believe this should work...

I'm trying to create a datatable class that will contain it's own copies of the objects passed to it. I've decided to use std::map's to contain this data. See the example code below:

typedef std::map <std::string, myVar *> myVarContainer;

class myObj
{
    public:
        myObj(void);
        virtual ~myObj(void);

        void setVar(std::string Key, myVar & Var);

        myVar * getVar(std::string Key);

        void release()
        {
            for (myVarContainer::iterator i = VarContainer->begin(); i != VarContainer->end(); ++i)
            {
                delete (i->second);
            }

            VarContainer->clear();
        };

        myVarContainer * VarContainer;

};

typedef std::map <myVar, myObj *> myRow;

class myTable
{
    public:
        myTable(void);
        virtual ~myTable(void);

        void addDataPoint(myVar RowID, myVar ColID, myObj * Data)
        {
            std::map <myVar, myRow *>::iterator i = m_Rows->find(RowID);

            if (i == m_Rows->end())
            {
                m_Rows->insert(make_pair(RowID, new myRow()));
            }
            i = m_Rows->find(RowID);

            // i thought the below line would be creating a copy of the data?
            // I thought this logic went:
            // 1. create a new object copied from the value of 'Data'
            // 2. return a pointer to this object and pair with the 'colID'
            // 3. make this into a pair and insert into the main map
            i->second->insert(make_pair(ColID, new myObj(*Data)));
        };

    protected:

        std::map <myVar, myRow *> * m_Rows;
}


int main()
{

    myVar a, b, c, d;

    myObj * o = new myObj();

    o->setVar("test", a);
    o->setVar("test2", b);

    myTable * tab = new myTable();

    myVar x1, y1, x2;

    tab->addDataPoint(y1, x1, o);

    o->release(); // this clears out both 'o' and the values in 'tab'!?!?

    //at this point tab has no data in its object at y1,x1???

    o->setVar("test3", c);
    o->setVar("test4", d);

    tab->addDataPoint(y1, x2, o);
}

What I'm noticing is that my data is deleted too early. I believe I've missed something... I had thought I was creating a copy of the data referenced by the pointer and then storing a newly instance'd pointer in my map... Any thoughts? I appreciate any help!

Answer 1

似乎您确实在创建对象的副本，但是当您释放（）时，您将释放VarContainer（删除所有项目并使用clear（）），因此，您之前创建的副本（带有指针的副本） ，而不是实际的容器）留有指向空容器的指针。

Answer 2

So one of the problems that using (owning) raw pointers in containers is that you need to manually delete the instances yourself. I presume that myObj::~myObj does just that (iterates the container deleting all elements before deleting the container itself).

The line:

i->second->insert(make_pair(ColID, new myObj(*Data)));

Is copy constructing a myObj from Data.

Unfortunately, because you are not defining a copy constructor for myObj the compiler will generate one for you which will just copy the pointer to the VarContainer member. It won't create a new copy of the map or anything that it refers to internally. Once a copy is created you then have two instances which both point to the same container and both instances think that they own it. When the first one gets destructed it will seem to ok but actually leaves the other instance pointing to freed memory. As soon as the longest lived instance tries to do anything using this container pointer something bad will happen.

You could fix this by storing the maps by value and not by pointer:

typedef std::map<std::string, myVar> myVarContainer;
typedef std::map<myVar, myObj> myRow;

Also change myObj::VarContainer to be a non-allocated member. This means that everything now gets copied correctly and a copy will not reference anything from the original.

Note that you can also use smart pointers (such as std::shared_ptr ) instead of raw pointers but you will still need to be careful with that as, although copying would be safe, they share data with the original which might not be what you expect.

You should take a look at the following:

http://en.wikipedia.org/wiki/Rule_of_three_(C%2B%2B_programming )