Concrete class not being constructed - c++

Question

I have a class hierarchy like this:
class Base {
public:
virtual bool foo() const = 0;
static Base& getHeadInstance();
};
class Concrete: public Base {
public:
explicit Concrete(Base& f): fwd(f) {}
// ... other member functions elided
bool foo() const override { return /* some calculation */ && fwd.foo(); }
private:
Base& fwd;
};
so that I can construct a series of instances like this:
Concrete c1(Base::getHeadInstance());
Concrete c2(c1);
Concrete c3(c2);
so that c3 can make decisions and possibly defer to c2, which in turn could defer to c1 and so on like the Chain of Responsibility pattern.
The problem is that c2 and c3 are not constructed correctly and their fwd member always refers to Base::getHeadInstance().
What is going wrong here and what is the fix for this?
Update:
It doesn't matter what the static member returns. Pretend it returns an instance of this:
class Head: public Base {
public:
Head() = default;
private:
bool foo() const override { return true; }
};
Base& Base::getHeadInstance(){ static Head head; return head; }

Answer 1

I've had this same problem before. It boils down to overload resolution on your custom constructor Derived(Base&) vs the implicitly defined copy constructor Derived(const Derived&);, where the implicit copy constructor simply wins. Deleting it does not fix this, it still participates in overload resolution (but it does stop the wrong thing from happening silently).
Here is a reduced example:
struct Base
{
virtual ~Base();
};
struct Derived : Base
{
Derived(Base&);
Derived(const Derived&); // Implicitly or explicitly declared in any case.
};
Derived getDerived();
void test()
{
Derived d1 = getDerived();
Derived d2(d1); // copies
}
https://godbolt.org/z/aoJFlC
There are several ways to get the code to do what you want the way you've written it (see other answers), but I would like to point out that you should take special care to save the next reader of your code from this same confusion you had. A cast to Base&, repurposed copy constructor semantics or something like using Derived(Base*); will all raise questions in future readers. You can try to solve that through documentation, but chances are somebody misses that and becomes confused. I would suggest making the intent as explicit and visible as possible, for example like this:
enum class ConstructFromBase { Tag };
struct Derived : Base
{
Derived(Base&, ConstructFromBase);
Derived(const Derived&) = delete;
};
Derived getDerived();
void test()
{
Derived d1 = getDerived();
Derived d2(d1, ConstructFromBase::Tag);
}
https://godbolt.org/z/QfeuAM
That should communicate the intent very clearly and costs virtually nothing. (There are many other ways to write and name such a tag, mine is probably not the most canonical...)

Answer 2

You have an implicit copy constructor you need to get rid of:
Concrete(const Concrete& c) = delete;
and you'll have to cast your c1 and c2
Concrete c1(Base::getHeadInstance());
Concrete c2((Base&)c1);
Concrete c3((Base&)c2);
Your other option is to template the constructor:
template<typename T>
Concrete(T& f): fwd(f) {}
and then your original code would work (Yay!).
Concrete c1(Base::getHeadInstance());
Concrete c2(c1);
Concrete c3(c2);

Answer 3

You just need to provide you own copy constructor that does what you want. Adding
Concrete(Concrete& c): fwd(c) {}
Will then make
Concrete c1(Base::getHeadInstance());
Concrete c2(c1);
Concrete c3(c2);
have c1.fwd == Base::getHeadInstance(), c2.fwd == c1, and c3.fwd == c2

Answer 4

Another possible solution is to avoid using references; even if I admit it is not isomorphic.
class Concrete : public Base {
public:
explicit Concrete(Base* f) : fwd(*f) {
// possibly you want to assert precondition? assert(f)?
}
private:
Base& fwd; // I would prefer Base* here...
};
In that way, you don't risk to call the implicit copy constructor of Concrete; without override o delete anything.
Concrete c1(&Base::getHeadInstance());
Concrete c2(&c1);
Concrete c3(&c2);