std::pair and class destructors

Question

Possible Duplicate:
What is The Rule of Three?

How exactly does std::pair call destructors for its components? I am trying to add instances of a class to an std::map, but I am getting errors regarding the destructor of my class.

I have narrowed down my question/problem to the following extremely simple example.

Below, my_class merely creates an int array at construction, and deletes it at destruction. Somehow I am getting a "double delete" error:

//my_class.h
class my_class {
  public:
    int an_int;
    int *array;

    //constructors:
    my_class()
    {
      array = new int[2];
    }
    my_class(int new_int) : an_int(new_int)
    {
      array = new int[2];
    }

    //destructor:
    ~my_class()
    {
      delete[] array;
    }
};  //end of my_class

Meanwhile, over in main.cpp...

//main.cpp
int main(int argc, char* argv[])
{
  std::map<int, my_class>   my_map;

  my_map.insert( std::make_pair<int, my_class> (1, my_class(71) ) );

  return 0;
} // end main

Compilation goes fine, but this generates the following runtime error:

*** glibc detected *** ./experimental_code: double free or corruption (fasttop):

Or, with valgrind:

==15258== Invalid free() / delete / delete[] / realloc()
==15258==    at 0x40249D7: operator delete[](void*) (vg_replace_malloc.c:490)
==15258==    by 0x8048B99: main (my_class.h:38)
==15258==  Address 0x42d6028 is 0 bytes inside a block of size 8 free'd
==15258==    at 0x40249D7: operator delete[](void*) (vg_replace_malloc.c:490)
==15258==    by 0x8048B91: main (my_class.h:38)

(line numbers are off because I cut out comments and stuff)

I must be missing something about std::pair...?

Thanks to all in advance!

Answer 1

When you add my_class to stl containers the copy constructor is called. As you don't define one it does a memberwise copy and two my_class objects are created that point to the same int array, When these are deleted the same int array might be deleted twice

Please take a look at Rule of three

In C++11 also look at move constructor if you are worried about the efficiency.

Answer 2

Your class violates the rule of three by defining a destructor without a copy constructor and an assignment operator. Once you define these, your code should run OK: STL containers rely heavily on these, so you should ask yourself if you've implemented all three every time you use a class as a template argument for an STL container.

Answer 3

You have to define a suitable copy constructor because copies of your class share the same array through copied instances of the pointers.

Answer 4

Rule of three is fancy. Standard containers are usually fancier.

---

The problem is that not the array is copied, but rather the pointers to them. Now if two instances hold the same pointers, you will be deleting the same array twice.

You could define proper copy operations for your class, but usually using standard containers solves all of your problems of copying, memory acquisition, memory freeing, self-assignment, exception guarantees.

• Use std::vector as a drop-in replacement for dynamic arrays.
• Use std::array as a drop-in replacement for fixed-size arrays.

If all your members have proper copy-semantics, your class does not even need explicit copying operations, so you save a lot of work and increase maintainability and reduce error chances.

So:

In general, prefer standard containers over manual arrays:

class my_class {
public:
    my_class()
    : new_int(0), array(2)
    {}

    my_class(int new_int)
    : an_int(new_int), array(2)
    {}

private:
    int an_int;
    std::vector<int> array; // do not expose them
}; 

or

class my_class {
public:
    my_class()
    : new_int(0)
    {}

    my_class(int new_int)
    : an_int(new_int)
    {}

private:
    int an_int;
    std::array<int,2> array; // do not expose them
}; 

Iff you must omit standard containers:

• Write a copy constructor.
• Write copy assignment. or
• Forbid copying altogether.

Buf before doing so, read about rule of three, be aware of the dangers of self assignment, know the swap trick (note: this is a common C++ idiom), and learn about exception safety (note: you'll find a lot of the book's content in the GotW series of articles for free).