声明不变的 static “默认”成员变量/函数的“正确”方法是什么？

Question

Given a simple, bare-bone, Vector3D example. How would one define static default "values", such that vec3<T>::ones (or vec3<T>::ones() ) provides a vec3<T>{T{1}, T{1}, T{1}} .

template <class T>
struct vec3 {
    using value_type = T;
    value_type x{}, y{}, z{};
    
    constexpr vec3(const value_type e0, const value_type e1, const value_type e2) noexcept 
      : x(e0)
      , y(e1)
      , z(e2) 
    { }

    // Option 1
    [[nodiscard]] constexpr static inline vec3 zeros() noexcept { return {0, 0, 0}; }
    
    // Option 2
    [[nodiscard]] constexpr static inline vec3 x_axis() noexcept { 
        constexpr static vec3 _x_axis{1, 0, 0};
        return _x_axis;
    }
    
    // Option 3
    const static inline vec3 ones = [](){ return vec3{1, 1, 1}; }();

};

I've commonly seen variations of the three options, and I have a few questions whether or not my understanding on this matter is correct:

• Option 1, to my understanding, serves as a "factory function" creating new vec3 instances for each invocation. Is this equivalent to any caller using the vec3{e0, e1, e2} directly?

• Option 2 creates one vec3 instance exactly once, the very first time the function is executed. Therefore, the compiler is required to make use of a synchronization primitive to ensure that static initialization happens exactly once. Do all future invocations simply return "the locally cached" value without any synchronization primitives?

• Option 3 creates a static inline member variable at compile time, I think? GCC allows the static inline variable to be declared as constexpr (which is why I believe everything happens at compile time), whereas clang only compiles with const (which does not guarantee compile time instantiation of the static member variable?).

Are there any other differences between these solutions that I am missing and should I prefer any? Are there any other ways to declare static members at compile time?

Answer 1

You can look at how it's done in the standard for std::strong_ordering :

class strong_ordering {
    // ...
public:
    // valid values
    static const strong_ordering less;
    static const strong_ordering equal;
    static const strong_ordering equivalent;
    static const strong_ordering greater;
    // ...
};
// valid values' definitions
inline constexpr strong_ordering strong_ordering::less(ord::less);
inline constexpr strong_ordering strong_ordering::equal(ord::equal);
inline constexpr strong_ordering strong_ordering::equivalent(ord::equivalent);
inline constexpr strong_ordering strong_ordering::greater(ord::greater);

So the strategy is static const declaration (without initializer) in the class, then inline constexpr definition (with initializer) outside the class to guarantee compile-time initialization and allow the variable to be used in constant expressions.

The reason why the declaration and definition need to be separated is that inside the class definition, the class is incomplete, and you can't have a static member definition with an incomplete type. Having a static constexpr data member in the class is defining it. ( inline is implied on such declarations.) So you have to have a non-defining declaration inside the class, and then a defining declaration later on after the class is complete. In the defining declaration (the definition), you can use constexpr .

So in your case it would look like this:

template <class T>
struct vec3 {
    using value_type = T;
    value_type x{}, y{}, z{};
    
    constexpr vec3(const value_type e0, const value_type e1, const value_type e2) noexcept 
      : x(e0)
      , y(e1)
      , z(e2) 
    { }

    static const vec3 ones;
};

template <class T>
inline constexpr vec3<T> vec3<T>::ones = {1, 1, 1};

In this case because vec3 is a template, I think you don't even need inline .