Arrays of Pointers to Abstract Types

Question

I have been experimenting with abstract types. The code below gives me a desired effect.

class base{
public:
 virtual void do_stuff() = 0;
};

class derived: public base{
public:
 void do_stuff(){/*stuff*/}
};

class manager{
 vector<shared_ptr<base>> ptrs;
public:
 void add(base* ptr){
  ptrs.emplace_back(ptr);
 }
};

manager foo;
foo.add(new derived());

Fine and dandy, but it's awkward because the user is not only dealing with pointers, but has to use new without ever calling delete. My question is if there's a way I can implement this where the user of manager doesn't ever have to deal with pointers or new.

foo.add(derived()); //example

My attempts to implement this end up as:

class manager{
 vector<shared_ptr<base>> ptrs;
public:
 void add(base& ref){
  ptrs.emplace_back(&ref);
 }
};

But, the compiler says no known conversion from 'derived' to 'base&'. I have no idea how to make a reference to base compatible with a reference to derived. How do I get around this?

Answer 1

Pass unique_ptr

Your add function takes ownership of this object. A safe way of passing ownership is to pass unique_ptr.

Using a unique_ptr is fairly flexible because you can construct a shared_ptr from a unique_ptr or if you change your mind in the future you can store the unique_ptr directly.

class manager{
  vector<shared_ptr<base>> ptrs;
public:
  void add(std::unique_ptr<base> ptr){
    ptrs.emplace_back(std::move(ptr));
  }
};

manager foo;
foo.add(std::make_unique<derived>());

Using a temporary std::unique_ptr you avoid the owning raw pointer that is not exception safe. By using make_unique you can avoid writing new.

Live demo.

Pass a Factory

Another option if the caller really doesn't want to have to deal with any kind of pointer is to pass some sort of Factory that the add function uses to construct the object. The Factory could simply be a static create function on the derived class itself:

using Factory = std::function<std::unique_ptr<base>()>;

class manager{
 std::vector<std::shared_ptr<base>> ptrs;
public:
 void addUsing(const Factory& factory){
  ptrs.emplace_back(factory());
 }
};

class derived : public base {
public:
 ...
  static std::unique_ptr<derived> create() { 
    return std::make_unique<derived>();
  }
};

manager foo;
foo.addUsing(derived::create);

Live demo.

Answer 2

You can let your add() function be passed the arguments to be used in the construction of type T, where T is specified as the type of a subclass.

template <typename T, typename... TArgs>
void add(TArgs&&... args)
{
    ptrs.emplace_back(std::make_shared<T>(std::forward<TArgs>(args)...));
}

Which can then be called as follows:

bm.add<derived_a>( "hello" ); // derived_a constructor takes a string
bm.add<derived_b>( 42 );      // derived_b constructor takes an int

Full example

#include <string>
#include <vector>
#include <memory>

class base
{
public:
    virtual void f() = 0;
};

class derived_a : public base
{
public:
    derived_a( std::string const& s ) : s_{ s } {}
    void f() override { std::cout << "derived_a::string = " << s_ << '\n'; }

private:
    std::string s_;
};

class derived_b : public base
{
public:
    derived_b( int i ) : i_{ i } {}
    void f() override { std::cout << "derived_b::int = " << i_ << '\n'; }

private:
    int i_;
};

class base_manager
{
public:
    template <typename T, typename... TArgs>
    void add( TArgs&&... args )
    {
        ptrs.emplace_back( std::make_shared<T>( std::forward<TArgs>( args )... ) );
    }

    void print() { for ( auto& d : ptrs ) d->f(); }

private:
    std::vector<std::shared_ptr<base>> ptrs;
};

int main()
{
    base_manager bm;
    bm.add<derived_a>( "hello" );
    bm.add<derived_b>( 42 );
    bm.print();
}

Answer 3

You can't pass a temporary (an r-value) to a non-const reference. Also you try to take the address of that temporary object, which will in the end produce a dangling pointer and undefined behavior.

Assuming you want to pass an object of unknown runtime type to the manager:
One thing you can do is using some sort of polymorphic copy mechanism (like a virtual clone method) and make an internal copy of the object on the heap (it has to be polymorphic, to avoid object slicing).

class base {
public:
    virtual void do_stuff() = 0;
    virtual shared_ptr<base> clone() const = 0;
    virtual ~base()=default;
};

class derived : public base {
    int data;
public:
    derived() :data(0) {};
    derived(const derived& other) :data(other.data)
    {};
    virtual shared_ptr<base> clone() const override { 
        return make_shared<derived>(*this); 
    };
    void do_stuff() {/*stuff*/ }
};

class manager {
    vector<shared_ptr<base>> ptrs;
public:
    void add(const base& obj) {
        ptrs.emplace_back(obj.clone());
    }
};
int main() {
    manager foo;
    foo.add(derived());
}

without the clone, it would look something like this:

void add(const base& obj) {
    if (typeid(obj)== typeid(derived) ){
        ptrs.emplace_back(make_shared<derived>(static_cast<const derived&>(obj)));              
    }
    else if (typeid(obj) == typeid(derived2)) { 
    ...         
}

Answer 4

Your original question seems to be concerned over the fact that the user/caller creates a pointer and hands it off and never deletes it. My example below, simply makes it explicit to the user that he can hand it off and forget about it. In otherwords, require the user to pass a shared_ptr...

#include <stdlib.h>
#include <vector>
#include <memory>

using namespace std;

class base{
public:
    virtual void do_stuff() = 0;
};

class derived : public base{
public:
    void do_stuff(){/*stuff*/ }
};

class manager{
    vector<shared_ptr<base>> ptrs;
public:
    void add(shared_ptr<base> ptr){
        ptrs.emplace_back(ptr);
    }
};

int main()
{
    manager foo;
    shared_ptr<derived> bp(new derived()); //require the user supply a smart pointer
    foo.add(bp);
    return 0;
}

This is simpler than the other posts, and may not be as forward thinking, but it does not require the derived class to implement additional base members. In many cases, it is may be enough.