将基类的const成员初始化为派生类

Question

public:
    const int x;
    base():x(5){}

};

class der : public base {
public:
    der():x(10){}
};

der d;

My aim is when instance of base class is created it will initialise x as 5 and when instance of der class is created it will initialise x as 10. But compiler is giving error. As x is inherited from class base, why is it giving error?

Answer 1

You can make this work with a little adjustment...

#include <cassert>

class base
{
public:
    const int x;
    base()
        :x(5)
    {
    }

protected:
    base(const int default_x)
        :x(default_x)
    {
    }
};

class der: public base
{
public:
    der()
        :base(10)
    {
    }
};

struct der2: public base
{
    der2()
        :base()
    {
    }
};

int main()
{
    base b;
    assert(b.x == 5);
    der d;
    assert(d.x == 10);
    der2 d2;
    assert(d2.x == 5);
    return d.x;
}

This provides a constructor, accessible by derived classes, that can provide a default value with which to initialise base.x .

Answer 2

You can't initialize a base class member in the initializer list for a constructor in the derived class. The initializer list can contain bases, and members in this class, but not members in bases.

Admittedly, the standardese for this isn't entirely clear. 12.6.2/2 of C++03:

Unless the mem-initializer-id names a nonstatic data member of the constructor's class or a direct or virtual base of that class, the mem-initializer is ill-formed.

It means "(a nonstatic data member of the constructor's class) or (a direct or virtual base)". It doesn't mean "a nonstatic data member of (the constructor's class or a direct or virtual base)". The sentence is ambiguous, but if you took the second reading then you couldn't put bases in the initializer-list at all, and the very next sentence in the standard makes it clear that you can.

As for why it's not allowed, that's a standard rationale question and I'm guessing at the motives of the authors of the standard. But basically because it's the base class's responsibility to initialize its own members, not the derived class's responsibility.

Probably you should add an int constructor to base .

Answer 3

This works.

class base {
public:
    static const int x = 5;
};

class der : public base {
public:
    static const int x = 10;
};

If you want to change x depending on your constructor, you have to make it non-static.

A non-static const is the same as a non-const variable once compiled. If you want to enforce a member variable to be read-only, use non-static const. If you want to set a constant whose scope is restricted to a single class, use static const.

Answer 4

This may be over-engineered compared the original question, but please consider:

template <typename T, class C, int index=0> 
// C and index just to avoid ambiguity
class constant_member {
    const T m;
    constant_member (T m_) :m(m_) {}
};

class base : virtual public constant_member<int, base> {
public:
    base () : constant_member<int, base>(5) {}
    int x () const { return constant_member<int, base>::m; }
};

class der : public base {
public:
    der () : constant_member<int, base>(10) {}
};

class der2 : public der{
public:
    der2 () {} // ill-formed: no match for 
               // constant_member<int, base>::constant_member() 
};

Comment: This is verbose, non-obvious (maybe impossible to understand for beginners), and it will be very inefficient to convert to virtual base class just to read a member variable. I am not really suggesting this as a real world solution.