How to properly free a set of pointers?

Question

If I have a container like a std::set of pointers to dynamic objects then how can I free its elements?

int main()
{

    // new scope
    {
        int x = 10;
        std::set<int*> spi;
        spi.insert(new int(1));// elem is a dynamic object init from 1
        spi.insert(new int[3]()); // elem is a dynamic array of 3 default-init integers
        spi.insert(&x); // elem is address of stack memory object
    }
}

So how I can free elements with dynamic memory efficiently?

I know I can use a set of shared_ptrs or unique_ptr but for practice sake I want to know how to.

you should track the memory you manually allocated in a separate collection. — Daniel A. White, Dec 29 '19 at 21:50
The proper way to efficiently free a set of pointers is to use a set of smart pointers. — eerorika, Dec 29 '19 at 21:51
Oh you must not mix data types and allocation strategies in a `std::set` like this, this is a very bad idea. — Brian Cain, Dec 29 '19 at 21:51

R Sahu · Answer 1 · 2019-12-30T19:01:53.243

7

You'll have to iterate over the contents of the container and deallocate memory corresponding to each element.

for ( auto ptr : spi )
{
   delete [] ptr;
}

However, remember that your posted code is problematic. You can't delete a pointer that is obtained by using the addressof operator. The following line will cause problem downstream if you try to call delete on all the elements of the container.

spi.insert(&x);

Avoid putting such mixed pointers in the container. You have no way to knowing which element was allocated using new and which element was obtained by using the addressof operator.

Not only that, if you add pointers obtained by new int(10) and new int[3] in the container, you will run into undefined behavior no matter whether you use delete or delete [] on the elments of the container. One of them will be wrong.

My suggestion is try to write clean code and not try to find creative ways of dealing with poorly written code.

edited Dec 30 '19 at 19:01

answered Dec 29 '19 at 21:50

R Sahu

204,454
14
159
270

1

wouldn't deleting the pointer of `x` cause undefined behavior? – Daniel A. White Dec 29 '19 at 21:50
@DanielA.White yes, it will. – R Sahu Dec 29 '19 at 21:51
1

Also `new int(1)` needs a plain `delete` without `[]`. – HolyBlackCat Dec 29 '19 at 21:53
2

@HolyBlackCat, it's a holy mess :) :) – R Sahu Dec 29 '19 at 21:55

score 3 · Answer 2 · answered Dec 29 '19 at 21:57

If you put non-owning pointers into a set, then a reasonable approach is to use the set exclusively for non-owning pointers. Therefore the dynamic objects must be owned by some other data structure. An example:

int x = 10;
auto y = std::make_unique<int>(1); // the dynamic object is owned by smart pointer
std::vector<int> z(3);             // the dynamic array is owned by vector

std::set<int*> spi;
spi.insert(y.get());
spi.insert(z.data());
spi.insert(&x);

score 2 · Answer 3 · answered Dec 29 '19 at 21:57

There is no way to do it.

You can't tell what each pointer points to (object on the stack, on the heap, or an array on the heap?), so there is no way to know how to dispose of them properly.

You either have to allocate each element in the same way, so they can be disposed of in the same manner, or store some additional information about each element.

How to properly free a set of pointers?

3 Answers3