How to properly implement creation (and allocation) of a list of objects known only by abstract base in C++?

Question

I should prefer stack allocation to heap allocation. It's better to pass by value (especially if you're creating new objects — but at the same time, if you return by base class, your object will be sliced), or at least by reference than passing pointers (although you can't create a vector of references).

I read all of this carefully, and now I feel that I know less that I knew before. I don't have a slightest idea about how to write a code that, IMO, should be trivial, while respecting the best practices mentioned in all of these well-written and thought-through answers.

Here's what I want to implement. (I don't pretend that it's correct C++, but I just want to convey the idea).

// This thing is purely virtual!
class BaseStuff { }

// Has important behaviour and data members that shouldn't be sliced
class SomeStuff : public BaseStuff { }

// Don't slice me plz
class OtherStuff : public BaseStuff { }

BaseStuff CreateStuff()
{
    // falls a set of rules to create SomeStuff or OtherStuff instance based on phase of the moon
}

std::vector<BaseStuff> CreateListOfStuff()
{
    // calls CreateStuff a lot
}

public static void main()
{
    List<BaseStuff> allTheStuff = CreateListOfStuff();
    // to things with stuff
}

Answer 1

If you want polymorphism, you have to use pointers.

BaseStuff* CreateStuff()
{
   ...
}

List<BaseStuff*> allTheStuff = CreateListOfStuff();

Indeed, you should prefer stack allocation to heap allocation, when possible. But it's not always possible.

Of course, instead of raw pointers, which are inherently unsafe, you may consider using smart pointers - unique_ptr, shared_ptr, etc, but smart pointers nonetheless

List<shared_ptr<BaseStuff>> = CreateListOfStuff

Answer 2

You're going to store polymorphic pointers to a base class that actually point to a derived type (note I used std::unique_ptrs here):

#include <iostream>
#include <memory>
#include <vector>

class Base
{
public:
  virtual void shout() = 0;
};
class Child : public Base
{
public:
  void shout() { std::cout << "Child!\n"; }
};
class Orphan : public Base
{
public:
  void shout() { std::cout << "Orphan!\n"; }
};

int main()
{
  std::vector<std::unique_ptr<Base>> the_list;
  the_list.reserve(3);
  the_list.emplace_back(std::make_unique<Child>());
  the_list.emplace_back(std::make_unique<Orphan>());
  the_list.emplace_back(std::make_unique<Child>());

  for(const auto& item : the_list)
  {
    item->shout(); // remember, items are (smart) pointers!
  }
}

Live example. You can only store one type in a Standard C++ container, so you must store a (smart) pointer to Base here.

Answer 3

One thing you frequently (usually?) do in situations like this is define a member function (traditionally named clone) in the base class to create a copy of an object:

class BaseStuff { 
public:
    virtual BaseStuff *clone() const = 0;
};

class SomeStuff : public BaseStuff {     
    virtual void SomeStuff *clone() const { 
        return new SomeStuff(*this); // needs a correctly functioning copy ctor
    }
};

class OtherStuff : public BaseStuff {
public: 
    virtual OtherStuff *clone() const { 
        return new OtherStuff(*this);
    }
};

This lets us copy an item via a pointer to the base, without slicing. This way if you want (for example) your ListOfStuff to store copies of the items you put into it (rather than just pointers to the original items, which may cease to exist, leaving dangling pointers) you can add an item something like this:

class ListOfStuff { 
    class Node {
        // Note: this is extremely incomplete. Almost certainly needs a dtor,
        // and you want to either implement or delete the copy ctor to either
        // do copying correctly, or assure it can't happen at all.
        Node *next;
        BaseStuff *data;
    public:
        Node(BaseStuff *data, Node *next = nullptr) : data(data), next(next) {}
    };

    Node *begin, *end;

public:
    Add(BaseStuff *item) { 
        BaseStuff *new_item = item->clone();
        end->next = new node(new_item);
        end = end->next;
    }    
};

With one minor modification, I'd agree with Armen Tsirunyan's basic point: when you're dealing with a polymorphic hierarchy, you normally have to do so via a pointer, or (the modification) a reference.

You can use smart pointers instead of pointers in many cases--but not in all cases, and choosing the correct smart pointer for a specific situation can be non-trivial in itself. You do usually want some sort of wrapper around your pointers though--the code above avoids them primarily because I don't know enough about what you're doing to pick the correct one.