C++ vector of pointers, vector declaration and deletion of pointers

Question

Let's assume I have a singleton class:

class Singleton {
public:
    static Singleton* getInstance();
    void doit();
    std::vector<Object*>& getVector();

private:
    std::vector<Object*> _vector;
    static Singleton *instance;
    Singleton();
    ~Singleton();
    Singleton(const Singleton&);
};

class Delegator {
public:
        void main();
}

• In the doit method I populate the _vector with pointers to objects.
• In the main() from the Delegator class, I call getVector() and display the results.

Given this abstraction, I have the following questions:

1. Can I delete all the pointers to instances of Object in the main() from Delegator (after displaying the results). If yes, is this recommended?
2. Does the singleton ever get destroyed? In other words, will the reference returned in getVector() always be valid?
3. I return a reference to a vector instead of a copy of the vector in getVector(). Given that the vector only contains pointers to objects and will not modify the vector content outside the Singleton class, is there any efficiency gained from returning a reference?

Thank you in advance

Answer 1

A typically singleton pattern looks like this (other variations are possible, like using reference instead of pointer for the instance).

singleton.h:

class Singleton {
public:
    static Singleton* getInstance();
    ...

private:
    static Singleton *instance;
    Singleton();                 //permit construction of instances
    ~Singleton();                //permit deletion of instances
    Singleton(const Singleton&); //don't provide an implementation for copy-ctr.
};

singleton.cpp:

Singleton *Singleton::instance = 0;

Singleton::Singleton() {
    // init your stuff
}

Singleton::~Singleton() {
}

Singleton *Singleton::getInstance() {
    if(!instance) instance = new Singleton();
    return instance;
}

In your case, you return a copy of a singleton instance, which violates the singleton pattern.

To answer your 2. question: A singleton should never be deleted. However, we define a destructor so we can make it private, otherwise the caller can delete Singleton::getInstance() which is not a good idea.

That being said, singletons are in most cases considered an anti-pattern. In very most cases a utility class is better suited. Utility classes are a very similar concept, but they implement everything static instead of using an instance. When you need initialization code, do this with an init() method (since no constructor involved).

Answer 2

1. That totally depends on your requirements and design. Your presented code is neutral from this perspective.

2. Again, that's up to your design and implementation. The singleton pattern itself doesn't imply lifetime. If you need the singleton to be valid for a certain lifetime, you need to ensure that by other means (e.g., define a global instance of it).

3. Yes, there is a performance gain. Instance of vector is not a simple array and contains a substantial amount of data besides the actual stored information. All the data will be copied if returned by value (put aside the optimizations for this discussion). Also, as was correctly noted in another answer, returning by value actually breaks the singleton pattern.

Answer 3

My first answer to the question you didn't ask is this:

Do not use Singleton. It's an anti-pattern. It makes the code it touches worse. It kills testability and makes it harder to modify your program in the future.

This really excellent article talks in great detail about why Singleton is a bad idea.

To answer the questions you did ask...

1. Yes, you can. Of course, those pointers will still be in the vector so the vector will now contain a ton of dangling pointers. So you ought to clear out the vector too.
2. With the code you have it will never be destroyed. By some definitions that makes your Singleton a memory leak. So yes, the reference will always be valid.
3. Yes, there is a huge performance improvement to returning a reference. Copying a vector means making a copy of all the elements in the vector. Note that this means all the pointers will be copied, not the Objects they point to. Additionally, if you return a copy and have the main function delete all the pointers you are absolutely guaranteed to have a vector lying around with a whole ton of dangling pointers in it.