在初始化列表中初始化静态成员

Question

How do I make G::t static? (eg, G::t should be of type const static int& ) G::t is defined by the constructor parameter p and not available anywhere else.

class G {
public:
    // I want to make this static.
    const int& t;

    G(const int& p);
};

G::G(const int& p) : t(p) {}

int main() {
    int a=2;
    const int& b = a;

    G g = G(b);
}

Answer 1

eg:

const int a = 10;

class foo
{
    static const constexpr int& t = a;
};

You can't initialize static member in constructor, because constructors are for objects, not for class as whole.

Answer 2

Why are you even using a constructor if you want to set static members to be used by static functions? That's not what constructors are for. You definitely can't initialize a static member in an initializer-list, because that would mean it got initialized every time you constructed another object. (Just think about the difference between per-class static data and per-instance data and it should be obvious why the question makes no sense).

You could use a static local, which is initialized on first use so can be initialized at run-time, and then can be accessed by the static member functions:

class G {
public:
    static int t(const int& p = 0, bool set = false);

    G(const int& p);
};

G::G(const int& p) { t(p, true); }

int G::t(const int& p, bool set)
{
    static bool is_set = false;
    if (!is_set)
    {
        if (!set)
            throw std::logic_error("Cannot use G::t before it is set");
    }
    else if (set)
        throw std::logic_error("Cannot set G::t more than once");
    static const int tt = p;
    set = true;
    return tt;
}

int main() {
    int a=2;
    const int& b = a;

    G g = G(b);
    int t = G::t();
}

But this is a horrible hack, you should think carefully about your design and whether using a constructor is appropriate here, or even if using a class is appropriate.

Answer 3

The member initializer list can only be used to initialize instance variables, so if t is static, you can only reassign it in the constructor body.

And because references can't be reassigned, you have to use a pointer. A reference_wrapper doesn't work because it would need to be statically initialized (unless you have a global int that you can use for that).

Eg

class G {
public:
    static const int* t;

    G(const int& p);
};

const int* G::t; // definition in .cpp

G::G(const int& p) {
    t = &p;
}