Is it possible to switch to a different base class constructor at runtime?

Question

Suppose I'm writing Derived and have to inherit from Base, which I don't control and has two separate constructors and a deleted copy and move constructors:

struct Base {
    Base(int i);
    Base(const char *sz);
    Base(const Base&) = delete;
    Base(const Base&&) = delete;
};

struct Derived {
    Derived(bool init_with_string);
};

Now, depending on the value of another_param I have to initialize my base class using either a constructor or the other; if C++ was a bit less strict it would be something like:

Derived::Derived(bool init_with_string) {
    if(init_with_string) {
        Base::Base("forty-two");
    } else {
        Base::Base(42);
    }
}

(this would also be useful for all the cases where it's cumbersome to calculate values to pass to base class constructors/fields initializers in straight expressions, but I'm digressing)

Unfortunately, even if I don't see particular codegen or object-model obstacles to this kind of thing, this isn't valid C++, and I cannot think of easy workaround.

Is there some way around this that I'm not aware of?

Answer 1

A static function will work fine here

struct Base {
    Base(int i);
    Base(const char *sz);
    Base(const Base&) = delete;
    Base(const Base&&) = delete;
};

struct Derived : Base {
   using Base::Base;

   static Derived construct(bool with_string) {
      if(with_string) return { "forty-two" };
      return { 42 };
   }
};

Notice that this does not require a move, nor a copy constructor. If you want to have this as a local, you need to bind it to a reference in order to avoid moving it

auto &&w = Derived::construct(true);
auto &&wo = Derived::construct(false);

Answer 2

Not ideal but I have used this technique when nothing better suggested itself, when the initialization of an object had to occur inside a code block:

// (Same base as your code)
#include <memory>

struct Derived : public Base {
    using Base::Base;
};

int main(int argc, char **argv)
{
    std::unique_ptr<Derived> pd;

    if ( argc == 2 )
    {
        pd = std::make_unique<Derived>(42);
    }
    else
    {
        pd = std::make_unique<Derived>("forty-two");
    }

    Derived &d = *pd;

   // use d, don't manually reset pd
}

Answer 3

Edit: The following approach is quite close to what you are after, using placement new:

struct Derived3 : Base
{
    Derived3::Derived3(bool init_with_string) : Base(42)
    {
        if(init_with_string)
        {
            // in case of any resources would have been allocated:
            this->~Derived3();
            new(this) Derived3("forty-two");
        }
    }
private:
    using Base::Base;
};

First I construct a Base object with one of the two types. If the type condition does not match, I need to destroy it again calling the destructor explicitly to avoid undefined behaviour (and to prevent leaks in case that Base allocated memory already). Afterwards, we can reconstruct the class using the other constructor. Well, and this is the drawback of this approach, we potentially allocate some memory in vain, just to release it afterwards again and then re-allocate it! At least, we create an object in vain in some of the cases.

So no non-plus-ultra solution, so I'll leave my previous approaches:

Currently offering two approaches, both not really what you are after, but for now, I did not get closer...

Well, the obvious and easy solution:

struct Derived1 : Base
{
    static Derived1* instance(bool init_with_string)
    {
        return init_with_string ? new Derived1("forty-two") : new Derived1(42);
    }
private: // or even not, then you can construct your derived classes directly...
    using Base::Base;
};
int main(int argc, char* argv[])
{
    Derived1* d1 = Derived1::instance(false);
}

Template variant:

struct Derived2 : Base
{
private:
    using Base::Base;
    template <bool>
    friend struct Derived2Maker;
};

template <bool InitWithString>
struct Derived2Maker : Derived2
{
    Derived2Maker() : Derived2(42) { }
};
template <>
struct Derived2Maker<true> : Derived2
{
    Derived2Maker() : Derived2("forty-two") { }
};
int main(int argc, char* argv[])
{
    Derived2* d2 = new Derived2Maker<false>();
}

Drawback: boolean parameter must be known at compile time...

Answer 4

It's not really the answer you're looking for, but if you can get to a point where the decision is exposed to the code calling the constructor, you can use a tag-dispatch template constructor with a generic lambda for constexpr-if (bingo!), as follows:

#include <type_traits>
#include <memory>

struct Base {
    Base(int) {};
    Base(const char *) {};
    Base(const Base&) = delete;
    Base(const Base&&) = delete;
};

struct Derived : Base{
    static std::unique_ptr<Derived> make_unique(bool init_with_string);

private:
    template<typename init_with_string_t>
    Derived(init_with_string_t);
};

template<typename init_with_string_t>
Derived::Derived(init_with_string_t) : Base([]{if constexpr(init_with_string_t::value) return "forty-two"; else return 42;}())
{
}

std::unique_ptr<Derived> Derived::make_unique(bool init_with_string)
{
    if (init_with_string)
        return std::unique_ptr<Derived>(new Derived(std::true_type{}));
    else
        return std::unique_ptr<Derived>(new Derived(std::true_type{}));
}

int main()
{
    auto d1 =  Derived::make_unique(true);
    auto d2 =  Derived::make_unique(false);
}

Live demo on wandbox

That's a C++17-heavy feature list, so clang 3.9 or gcc 7. As I did here, you can wrap up the tag-dispatch call with a factory, and if you make that a static member of the class, you can put the logic that selects whether to initialise with a string or a value in a private static class method, or inline in the factory method as you prefer.

Some less-than-pleasant issues I had to work around to get this working:

The type-dispatch is needed because even through we could have Derived's constructor be:

template<bool init_with_string>
Derived::Derived() : Base([]{if constexpr(init_with_string) return "forty-two"; else return 42;}())
{
}

there's actually no way to explicitly specify template parameters to a constructor, and template deduction cannot deduce non-type template parameters. (If you have access to a constexpr value in scope, you could probably do something like template<bool init_with_string = constexpr_bool_method()> but if you could do that, you could put that straight in the lambda.

The if constexpr lambda idea came from an answer to Equivalent ternary operator for constexpr if?, which would have been nicer.

Sadly, we can't use std::make_unique in a factory method to access private constructors, because friendship isn't transitive.

Answer 5

Honestly you should just respect the implementation of Base and let Derived have two constructors.

class Derived : Base {
    Derived(int i) : Base(i) {}
    Derived(const char *s) : Base(s) {}
}

Then as Johannes Schaub remarked it's actually possible to have an external make_derived() using initializer lists even without copy constructors.