Question

I have a class called Foo which has a member that is a pointer to a vector of pointers to another class called Bar. I initialise it in the constructor but I’m not sure how to deallocate it in the destructor. I’m still learning. Would appreciate your help. The reason for having this member is so that the scope persists beyond that method i.e. beyond the stack. Thanks.

#include <iostream>
#include <vector>

using namespace std;

class Bar {};

class Foo {
public:
    Foo() {
        bars = new vector<Bar*>*[10];

        for (int i = 0; i < 10; i++) {
            bars[i]->push_back(new Bar());
        }
    }

    ~Foo () {
        for (int i = 0; i < 10; i++) {
            // TODO: how to clean up bars properly?
        }
    }

private:
    vector<Bar*>** bars;
};

int main () {
    new Foo();
    return 0;
}

Update: I appreciate the feedback on all fronts. I’m new to C and C++. Basically I wanted a 2d structure as a class member that would persist for the lifetime of the class. The reason the outer structure is an array is because I know how big it needs to be. Otherwise I was previously using vector of vectors.

Answer 1

The number of pointers is a bit ridiculous, as all they are doing is causing confusion and leaks, as evident from non-proper initialization and the question’s title. You don’t actually need any pointers at all, and don’t have to worry about any cleanup.

For a 2D array with the first dimension passed into the constructor, you can use a vector of vectors:

std::vector<std::vector<Bar>> bars; 

To initialize the outer vector with the passed in size, use an initializer:

Foo(size_t size) 
    : bars(size) {}

When the object is destroyed, bars and all of it elements are as well, so there’s no chance of forgetting to clean up or doing so improperly.

If performance is an issue, this can be translated into a sort of Matrix2D class that acts like a 2D array, but really only has an underlying 1D array.