c++使用内部类指针类型定义模板类的静态成员

发布于 2024-08-25 23:55:19 字数 334 浏览 4 评论 0原文

我有一个像这里一样的模板类（在标头中），其中包含一个内部类和一个指向内部类的类型指针的静态成员，

template <class t> class outer {
    class inner {
        int a;
    };

    static inner *m;
};

template <class t> outer <t>::inner *outer <t>::m;

当我想定义该静态成员时，我说“错误：预期的构造函数、析构函数或类型转换在 '* 之前最后一行的“令牌”(mingw32-g++ 3.4.5)

原文

I have a template class like here (in a header) with a inner class and a static member of type pointer to inner class

template <class t> class outer {
    class inner {
        int a;
    };

    static inner *m;
};

template <class t> outer <t>::inner *outer <t>::m;

when i want to define that static member i says "error: expected constructor, destructor, or type conversion before '*' token" on the last line (mingw32-g++ 3.4.5)

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

浊酒尽余欢 2024-09-01 23:55:19

您需要限定 inner 类是一个类型名称，因为它依赖于模板参数，并且 C++ 编译器假定名称 inner 在此上下文不是类型：

template <class t> typename outer<t>::inner* outer<t>::m;

基本原理：上行中的名称inner取决于类型名称t。此时，C++ 编译器不知道 inner 是什么，因为 inner 名称的含义可能因 t 的不同而不同。例如，假设代码中的其他位置有 int 的 outer 类的专用版本：

template <>
class outer<int> {
    int inner;
};

现在，outer::inner 不再命名类型；它命名一个成员变量。

因此，在一般情况下，outer::inner 的含义将是不明确的，C++ 会假设 inner 不这样做，从而解决了这种歧义。命名一个类型。除非您这么说，否则请在其前面添加 typename 前缀：typename external::inner。（在这种情况下，inner 被称为依赖名称，因为它取决于 t 的确切类型。）

You need to qualify that the inner class is a typename, since it’s dependent on a template parameter and the C++ compiler assumes that the name inner in this context is not a type:

template <class t> typename outer<t>::inner* outer<t>::m;

Rationale: the name inner in the above line depends on a type name, t. The C++ compiler at this point doesn’t know what inner is, because the meaning of the name inner can differ depending on t. For example, suppose that, somewhere else in the code, there is a specialized version of the outer class for int:

template <>
class outer<int> {
    int inner;
};

Now, outer<int>::inner no longer names a type; it names a member variable.

Thus, in the general case the meaning of outer<t>::inner would be ambiguous and C++ resolves this ambiguity assuming that inner does not name a type. Unless you say it does, by prefixing it with typename: typename outer<t>::inner. (In this context, inner is called a dependent name since it depends on the exact type of t.)