你将需要一个模板，并改变继承以使用模板，正如你将看到的。诀窍是使它工作，无论派生类是否有一个X来覆盖基类X。

template<class C>
struct A {
    static const int X = 1;
    template<typename T>
    static int getX(decltype(T::X)*) 
        { return T::X; }
    template<typename T>
    static void getX(...)
        { return X; }
    static void printX()
        { std::cout << "X " << getX<C>(0) << std::endl; }
};

struct B: public A<B> {
    static const int X = 2;
};

struct B2: public A<B2> {
    // No X
};

int main(){
    B b;
    b.printX(); // Prints X 2
    B2 b2;
    b2.printX(); // Prints X 1
}

只需将X的值作为模板参数：

#include <iostream>

template<int XValue=1>
struct A {
        static const int X = XValue;
        static void printX() {std::cout << "X " << X << std::endl; };
};

template<int XValue=2>
struct B: public A<XValue> {
};

struct C: public B<3> {
};

int main(int, char**){
        B<> b;
        b.printX();
}

根据定义，你对静态成员所做的任何事情都是“覆盖”，而不是“重写”。因为这将使用遮蔽，所以行为将完全取决于编译时类型，而不是运行时类型。

我不使用static和template，而只使用常规的常量属性和构造函数。
例如：

#include <iostream>

struct A {
    A(const char* fn, const int X) : filename(fn), X(X) {};
    void print() { std::cout << "X = " << X << ", FN = " << filename << std::endl; };

  protected:
    const char* filename;
    const int X;
};

struct B : public A {
    B() : A("data.dat", 5) {};
};

int main(int, char **) {
    B b;
    b.print();
}

在功能上，它完全按照您的要求执行。输出：

X = 5, FN = data.dat

• 现在编译器的工作就是优化这些常量，如果你不打算使用数以千计的对象B，那么把这些常量设为static就不值得你操心了。

简短回答：你不能。
稍微长一点，更复杂的答案：好吧，也许你可以。用模板！

#include <iostream>

template <typename T> struct A 
{
    static const int X = 1;

    static void printX() 
    { 
        std::cout << "X=" << T::X << std::endl; 
    }
};

struct B : public A<B> 
{
    static const int X = 2;
};

int main(int, char **)
{
    B b;

    b.printX();

    return 0;
}

好吧，我会沿着的……你想把这个嵌套得比一层深。好吧。

#include <iostream>

template <int XX> struct T
{
    static const int X = XX;

    static void printX()
    {
        std::cout << "X=" << X << std::endl;
    }   
};

struct AA 
{
    static const int X = 1;

    /* all other members go here */
};

struct A : public AA, public T<AA::X>
{
    /* empty - put stuff in AA instead */
};

struct BB : public AA
{
    static const int X = 2;
};

struct B : public BB, public T<BB::X>
{
};

struct CC : public BB
{
    static const int X = 3;
};

struct C : public CC, public T<CC::X>
{
};

struct DD : public CC
{
    static const int X = 4;
};

struct D : public DD, public T<DD::X>
{
};

int main(int, char **)
{
    A a;
    B b;
    C c;
    D d;

    a.printX();
    b.printX();
    c.printX();
    d.printX();

    return 0;
}

你甚至可以在每个类中跳过static const int X = ...;，只需要做public T<1>，public T<2>等。

为什么不使用模板？

constexpr int nfo[]{ 0, 1, 2, 3 };

template <int N>
class Haha {
public:
        const static int BOOM = nfo[ N ];
};
int main() {
        std::cout << Haha<2>::BOOM << std::endl; // 2
}