Vector of pointers template clearing function fails to compile with "undefined reference" message

Question

Hello all,

For a program of mine I made a small function to clear the various std::vectors of pointers that I have.

template <class S>
void clearPtrVector(std::vector<S*> &a,int size)
{
    for(size_t i = 0; i < size; i++)
         delete a[i];

    a.clear();
}

I must have done something wrong here though since when calling this function in a destructor like so :

clearPtrVector(neurons,neurons.size());

I get the following undefined reference two times:

undefined reference to `void clearPtrVector<Neuron>(std::vector<Neuron*,std::allocator<Neuron*> >&, int)'

I have to admit I am not familiar with what the std::allocator is, so I can not guess what the problem might be here. Any help is really appreciated. Thanks in advance!

-Lefteris

Answer 1

Hot Fix

Write following instead:

  template <class Vector>
  void clearPtrVector(Vector &a)
  {
    for(size_t i = 0; i < a.size(); i++)
         delete a[i];

    a.clear();
  }

Make sure you define the template somewhere where compiler can see it before each use of the template. If you do not create a declaration, you should be safe, as otherwise you should get a compile error. If you do create a declaration for any reason, be double carefull to include definition everywhere as needed.

Redesign

That said, I think the proper solution would be to rethink your design and to use a container which will handle the destruction properly, so that you do not have to do it manually, which is tedious, and almost impossible to do correctly if you need exception safety. Use std::shared_ptr instead of raw pointers, or std::auto_ptr with a container which is able to hold them (std::vector cannot store auto_ptr values). One possible solution would be to use Boost Pointer Container

Answer 2

Is your clearPtrVector implementation in a header file? Because if it's in a separate .cpp file, the linker will not find it.

Answer 3

Make sure you have this function in a header file (.h, *.hpp) because if you defined it in a source file with a prototype in a header file you'll got an undefined reference linker error.

Undefined reference error means that compiler has found the reference of the function but linker has failed to find an reference of that function amongst object files. Any template function has to be defined in a header file so the compiler will be able to put it in any source file which makes use of the function.

Answer 4

A few things:

In your original code, don't pass in the size; just get it from the vector:

template <class S>
void clearPtrVector(std::vector<S*> &a)
{
    for(size_t i = 0; i < a.size(); ++i)
    {
         delete a[i];
    }

    a.clear();
}

Secondly, just pass in the vector itself, not the type it points to:

template <class Vector>
void clearPtrVector(Vector &vec)
{
    for(size_t i = 0; i < vec.size(); ++i)
    {
         delete vec[i];
    }

    vec.clear();
}

Thirdly, that error sounds like you have it placed in a .cpp file. The code will be generated when you first call the function, which means the compiler needs to know the definition of the function. Move the function into the header file, so the compiler can find it.

Lastly, consider using things more suited to this:

• Boost Pointer Container
• A std::vector with a smart pointer, specifically a shared_ptr, as auto_ptr will not work.

Answer 5

Isn't the redesign a duplicate of cleaning-up-an-stl-list-vector-of-pointers

Remark

If you don't use one of the smart pointers, use boost::checked_delete function instead of delete to make sure you are not deleting an incomplete type.

Answer 6

As I provided in my answer to your first question http://stackoverflow.com/questions/891913?sort=newest, one answer is as follows:

template <class C> void FreeClear( C & cntr ) {
    for ( typename C::iterator it = cntr.begin(); 
              it != cntr.end(); ++it ) {
        delete * it;
    }
    cntr.clear();
}

which works for all container types. Notice that the size parameter is NOT provided but is obrtained from the collection - this is the correct way to design such functions, providing the size as a separate value can only lead to disaster.