c++ - 访问与内部类型同名的静态成员

Question

我有几个定义序列的类，这些序列的值必须在编译时通过 value 成员提供，并在运行时作为该类型的实际实例提供。所以我的算术序列的基本类型看起来有点像这样，

template<int A, int D>
struct ArithmeticSequence : public Sequence {
    ArithmeticSequence(VALUE v)
        : Sequence(v) {}

    template<unsigned int N>
    struct VALUE_N : public VALUE {
        static const int value = A+(D*N);
        operator int() { return value; }
    };
};

class Sequence 目前只定义了一个内部类 VALUE(当前为空)和一个采用 VALUE 的构造函数，但我将移动VALUE_N 的 operator int() 到 VALUE 和 Sequence 将进一步定义迭代器等。

现在，类应该从 ArithmeticSequence 扩展并为序列的每个成员定义常量。我有两种我认为适用的方法，如果我不介意序列的实例能够从相关序列的成员构造(即具有相同初始值和公差的序列)，我可以使用 typedef:

struct mySequence : public ArithmeticSequence<0,1> {
    mySequence(VALUE val = VALUE_N<0>::value)
        : ArithmeticSequence(val) {}

    typedef VALUE_N<0> zeroth;
    typedef VALUE_N<1> first;
    // ...
};

如果这样做，我可以从 VALUE_N 扩展:

struct mySequence : public ArithmeticSequence<0,1> {
    mySequence(VALUE val = VALUE_N<0>::value)
        : ArithmeticSequence(val) {}

    struct zeroth : public VALUE_N<0> {};
    struct first  : public VALUE_N<1> {};
    // ...
};

在这两种情况下，我认为我可以使用 mySequence::zeroth::value 在编译时获取值，并使用 mySequence::zeroth()获取运行时对象。但是，使用第二种方法会导致编译器混淆我是在声明一个函数还是在初始化一个实例，所以我需要 mySequence s1 ((mySequence::zeroth())); 而不是 mySequence s1 (mySequence::zeroth()).

现在，我发现以下是有效的，

struct mySequence : public ArithmeticSequence<0,1> {
    mySequence(VALUE val = VALUE_N<0>::value)
        : ArithmeticSequence(val) {}

    struct zeroth : public VALUE_N<0> {};
    static const zeroth zeroth;
    struct first  : public VALUE_N<1> {};
    static const first first;
    // ...
};

但我的问题(最后)是，关于我在任何时候访问哪一个的规则是什么？我可以使用 static const int i = mySequence::zeroth::value 和 mySequence s1 (mySequence::zeroth)，所以正确的事情似乎在那里发生了，但是如果我说 mySequence::zeroth z 而不是将 zeroth 视为一个类，它会将其视为变量。在这种情况下这不是问题，因为我不希望人们创建新的 mySequence::zeroth 或任何其他值，但我想如果我不明白它何时会使用每个值我以后可能会惹上麻烦。

对于超长的帖子，我们深表歉意，并提前感谢您花时间和耐心等待任何人走到这一步。我现在想知道我是否应该把所有的背景故事都写进去，或者只是问这个问题，如果我应该达成共识，我会把它编辑下来。谢谢。

编辑。请注意，正如我在上面所写的那样，使用 struct 方法而不是 typedef 确实不提供任何保护来防止使用另一个“相关”序列成员来构造序列对象，这是必需的，我想一想，但是最后一个例子是可行的。

Answer 1

枚举器、函数和对象的名称隐藏了在同一范围内声明的枚举和类的名称。在您的情况下，数据成员名称隐藏了结构的名称。您可以通过特殊查找访问隐藏的类型名称:

• 通过忽略对象、函数和枚举器名称来查找 :: 之前的名称。
• 用于指定基类的名称会忽略任何非类型名称。
• 在详细类型说明符中指定的名称忽略对象、函数和枚举器名称。

因此，下面详细说明的类型说明符是有效的并且指的是类

struct mySequence::zeroth var;

另外，请注意，当在类作用域中，成员声明更改了该声明中使用的名称的含义时，它是格式错误的。在您的情况下，让我们首先采用 static const；。第一个名称将引用类型，但在 mySequence 的完整范围内，该名称将引用数据成员。标准说

A name N used in a class S shall refer to the same declaration in its context and when re-evaluated in the completed scope of S. No diagnostic is required for a violation of this rule.

您的编译器不需要对其进行诊断，这是一个短语，意思是它实际上是未定义的行为(好的编译器会警告您类似“成员更改名称的含义”)。尽管我怀疑上述规则是否适用于这种情况(正如其措辞，但它确实适用)，您可以使用详细的类型说明符清除代码

struct first  : public VALUE_N<1> { };
static const struct first first;

请注意，您需要在静态成员的类外定义中使用详细类型说明符。一些编译器也允许您使用注入(inject)的类名来引用类型(GCC 过去这样做)

const struct mySequence::first mySequence::first;

以下使用注入(inject)的类名。 first 出现在 :: 之前并忽略数据成员。但是编译器必须在 first 的构造函数中查找名称 mySequence::first::first 而不是它的类类型

const mySequence::first::first mySequence::first;