Calling different base class constructors depending on input parameter value

Question

I have the following scenario:

Depending on the input value to a Derived class's constructor I need to call a different Base class constructor.

Such as:

struct Base
{
    Base() : v(0) {}
    Base(int _v) : v(_v) {}

    int v;
};

struct Derived
{
    Derived(int v) /* if v == 42 call Base() else call Base(int) */ {}
};

int main()
{
    Derived f2(42);
    Derived f1(1);
}

With my current knowledge of C++ I think this is not possible, so I ask the community if they are aware of any hacks, or dirty code that will make this feasible. Please don't let the simple ints misguide you, the real life scenario is much more complex. Feel free to mix in C++11 magic.

Edit: Also, I don't want to use an "init" function which depending on the value of the parameter initializes differently the things.

Answer 1

This is indeed a quite a strange request, maybe you should reconsider the general approach. What is the meaning of this particular 42 value? What is the question for which 42 is the answer? Maybe you should have two sibling Deriveds, or subclass Derived for x==42 case or for x!=42 case, etc. Or maybe 42 comes from a different-type object and you can use a separate constructor for that type?

But if you indeed want to accomplish what you have asked, one possible approach is to have two somehow different constructors in Derived and a "named constructor" (static function) to route between them. Something like (did not check for compilability, but the idea should be clear):

struct Derived {
private:
    Derived(int x): Base(x) {} 
    Derived(): Base() {}
public:
    static Derived ConstructDerived(int x) {
        if (x==42) return Derived();
        else return Derived(x);
    }
};

// usage
Derived a = Derived::ConstructDerived(42);
Derived b = Derived::ConstructDerived(43);

For this you will also need copy constructor, but you can also return pointers etc.

Another approach, if the value of 42 is fixed at compile time, is to use templates and specialize the constructor or even the class for a particular value of 42.

Another approach that I think should work, require base class to be copy- or move-constructible:

struct Derived {
    Derived(int x): Base( (x == 42)? Base() : Base(x) ) {}
};