C++ 我必须将“模板”和“类型名称”关键字放在何处以及为什么？
在模板中，我在哪里以及为什么必须将typename和template放在从属名称上？ 到底什么是从属名称 我有以下代码：C++ 我必须将“模板”和“类型名称”关键字放在何处以及为什么？,c++,templates,typename,c++-faq,dependent-name,C++,Templates,Typename,C++ Faq,Dependent Name,在模板中，我在哪里以及为什么必须将typename和template放在从属名称上？ 到底什么是从属名称 我有以下代码： template <typename T, typename Tail> // Tail will be a UnionNode too. struct UnionNode : public Tail { // ... template<typename U> struct inUnion { // Q: where t
template <typename T, typename Tail> // Tail will be a UnionNode too.
struct UnionNode : public Tail {
// ...
template<typename U> struct inUnion {
// Q: where to add typename/template here?
typedef Tail::inUnion<U> dummy;
};
template< > struct inUnion<T> {
};
};
template <typename T> // For the last node Tn.
struct UnionNode<T, void> {
// ...
template<typename U> struct inUnion {
char fail[ -2 + (sizeof(U)%2) ]; // Cannot be instantiated for any U
};
template< > struct inUnion<T> {
};
};
typedef typename Tail::inUnion<U> dummy;
template <typename T, typename TypeList> struct Contains;
template <typename T, typename Head, typename Tail>
struct Contains<T, UnionNode<Head, Tail> >
{
enum { result = Contains<T, Tail>::result };
};
template <typename T, typename Tail>
struct Contains<T, UnionNode<T, Tail> >
{
enum { result = true };
};
template <typename T>
struct Contains<T, void>
{
enum { result = false };
};
PS2：请看，特别是在Andrei Alexandrescu的书中：现代C++设计< /P> < P>见
< >为了分析C++程序，编译器需要知道某些名称是否为类型。以下示例说明：t * f;
// t::x is taken as non-type, but as an expression the following misses an
// operator between the two names or a semicolon separating them.
t::x f;
boost::function< int() > f;
template<typename T>
struct A {
typedef int result_type;
void f() {
// error, "this" is dependent, "template" keyword needed
this->g<float>();
// OK
g<float>();
// error, "A<T>" is dependent, "typename" keyword needed
A<T>::result_type n1;
// OK
result_type n2;
}
template<typename U>
void g();
};
template<>
struct C<int> {
typedef bool result_type;
typedef int questionable_type;
};
C++ 11规则使得下列有效C++ 03代码不正确，这不是C++委员会的意图，但可能不一定是固定的< /P>
struct B { void f(); };
struct A : virtual B { void f(); };
template<typename T>
struct C : virtual B, T {
void g() { this->f(); }
};
int main() {
C<A> c; c.g();
}
template<typename T>
struct test {
using type = T; // no typename required
using underlying_type = typename T::type // typename required
};
template<typename T>
struct test {
// typename required
using type = typename std::conditional<true, const T&, T&&>::type;
// no typename required
using integer = std::conditional<true, int, float>::type;
};
template< typename T > void foo( T& x, std::string str, int count )
{
// these names are looked up during the second phase
// when foo is instantiated and the type T is known
x.size(); // dependant name (non-type)
T::instance_count ; // dependant name (non-type)
typename T::iterator i ; // dependant name (type)
// during the first phase,
// T::instance_count is treated as a non-type (this is the default)
// the typename keyword specifies that T::iterator is to be treated as a type.
// these names are looked up during the first phase
std::string::size_type s ; // non-dependant name (type)
std::string::npos ; // non-dependant name (non-type)
str.empty() ; // non-dependant name (non-type)
count ; // non-dependant name (non-type)
}
template<typename T>
struct test {
using type = T; // no typename required
using underlying_type = typename T::type // typename required
};
template<typename T>
struct test {
// typename required
using type = typename std::conditional<true, const T&, T&&>::type;
// no typename required
using integer = std::conditional<true, int, float>::type;
};
template< typename T > void foo( T& x, std::string str, int count )
{
// these names are looked up during the second phase
// when foo is instantiated and the type T is known
x.size(); // dependant name (non-type)
T::instance_count ; // dependant name (non-type)
typename T::iterator i ; // dependant name (type)
// during the first phase,
// T::instance_count is treated as a non-type (this is the default)
// the typename keyword specifies that T::iterator is to be treated as a type.
// these names are looked up during the first phase
std::string::size_type s ; // non-dependant name (type)
std::string::npos ; // non-dependant name (non-type)
str.empty() ; // non-dependant name (non-type)
count ; // non-dependant name (non-type)
}
template<typename T>
struct test {
template<typename U>
void get() const {
std::cout << "get\n";
}
};
template<typename T>
void func(const test<T>& t) {
t.get<int>(); // error
}
我把JLBorges的优秀文章逐字逐句地放到cplusplus.com上的一个类似问题上，因为这是我读过的关于这个主题的最简洁的解释 在我们编写的模板中，有两种名称可以使用-依赖名称和非依赖名称。从属名称是依赖于模板参数的名称；无论模板参数是什么，非从属名称都具有相同的含义 例如：
template<typename T>
struct test {
using type = T; // no typename required
using underlying_type = typename T::type // typename required
};
template<typename T>
struct test {
// typename required
using type = typename std::conditional<true, const T&, T&&>::type;
// no typename required
using integer = std::conditional<true, int, float>::type;
};
template< typename T > void foo( T& x, std::string str, int count )
{
// these names are looked up during the second phase
// when foo is instantiated and the type T is known
x.size(); // dependant name (non-type)
T::instance_count ; // dependant name (non-type)
typename T::iterator i ; // dependant name (type)
// during the first phase,
// T::instance_count is treated as a non-type (this is the default)
// the typename keyword specifies that T::iterator is to be treated as a type.
// these names are looked up during the first phase
std::string::size_type s ; // non-dependant name (type)
std::string::npos ; // non-dependant name (non-type)
str.empty() ; // non-dependant name (non-type)
count ; // non-dependant name (non-type)
}
class A { public: typedef int type; static const int val { 1 }; };
class B { public: typedef float type; static const int val { 2 }; };
template<typename T> class C {};
template<int I> class D {};
template<typename T> class X {
T::type v; // OK
T::type f(T::type arg) { return arg; } // OK
T::type g(double arg) { return static_cast<T::type>(arg); } // OK
// C<T::type> c1; // error
D<T::val> d; // OK (as has always been)
C<typename T::type> c2; // OK (old style)
typedef T::type mytype; // OK
using mytypeagain = T::type; // OK
C<mytype> c3; // OK (via typedef / using)
};
X<A> xa;
X<B> xb;
Dependent name是一个依赖于模板参数的名称，我们需要指示编译器在实际输入模板类/函数之前正确编译模板类/函数 typename->告诉编译器依赖名称是实际类型
template <class T>
struct DependentType
{
typename T::type a;
using Type=typename T::type;
};
template <class T>
struct DependentTemplate
{
// template function
template <class U>
static void func() {}
// template class
template <class U>
struct ClassName{};
};
template <class T1, class T2>
void foo()
{
// 3 ways to call a dependent template function
DependentTemplate<T1>::template func<T2>();
DependentTemplate<T1>().template func<T2>();
(new DependentTemplate<T1>())->template func<T2>();
// You need both typename and template to reference a dependent template class
typename DependentTemplate<T1>::template ClassName<T2> obj;
using Type=typename DependentTemplate<T1>::template ClassName<T2>;
}
政治敏感性，可移植性。我问了你的实际问题，模板/字体名放在哪里？将最后一个问题和代码放在开头，并水平缩短代码以适应1024x屏幕，这样会更好地脱颖而出。从标题中删除从属名称，因为似乎大多数对typename和template感到好奇的人都不知道从属名称是什么。这样应该不会让他们太困惑了。@MSalters:boost非常便携。我想说，只有政治才是推动经济增长常常被忽视的一般原因。我知道的唯一好的原因是构建时间的增加。否则，这一切都是因为重新发明轮子而损失了数千美元。现在在我看来，char失败了[-sizeofU]；//无法为任何U实例化将不起作用，因为-sizeofU仍然始终为正，因此它可能仍然适用于某些或a
例如，如果您试图用U==int调用Union:：operator=U，那么ll U.inUnion将被实例化。它调用私有setU，inUnion*=0。而result=true/false的工作是我需要boost:：enable_if<>，这与我们当前的OSX工具链不兼容。但是，单独的模板仍然是一个好主意；线这将实例化Tail。但不是在学校里。当它需要它的完整定义时，它会被实例化。例如，如果使用sizeof，或者使用：：foo访问成员，就会发生这种情况@MSalters无论如何，您还有另一个问题：-sizeofU从不为负：因为size\u t是无符号整数类型。你会得到一些非常高的数字。您可能想执行sizeofU>=1-1:1或类似：。。。那么字符f[sizeofU>=1？-1:1]或-sizeofU永远无效。我很久以前就看过了，但今天早上我又找到了那一段：14.6/7。不要求它拒绝，但它可以这样做。但是，如果你只是把模板声明放进去，就没问题了。这个答案是从我之前删除的FAQ条目中复制出来的，因为我发现我应该更好地使用现有的类似问题，而不是为了回答它们而编造新的伪问题。感谢go to，他编辑了最后一部分中禁止使用typename/template的案例的想法。你能帮助我什么时候使用这种语法吗？这个->模板f；我得到了这个错误“template”，因为消歧器只允许在模板中使用，但没有模板关键字，效果很好。我今天问了一个类似的问题，很快就被标记为重复：。我奉命重新提出这个问题，而不是提出一个新问题。我必须说我不同意它们是重复的，但我是谁，对吗？那么，有什么理由在语法不允许除类型名以外的其他解释的情况下强制使用typename吗？@Pablo你没有遗漏任何东西。但仍然需要编写消歧代码，即使整行不再含糊不清。@L.F.请创建一个新的C++20答案，正如我在C++ 11FYI中所做的那样，这里的答案是：这个答案中的大部分代码没有在各种编译器上编译。@ AdAMrACKISE假设C++规范自2013个日期以来没有改变，我写了这个答案，然后尝试了代码，但是没有实现这个C++ 11 +特性。
struct X { typedef int foo; }; /* (C) --> */ f_tmpl<X> ();
struct Y { static int const foo = 123; }; /* (D) --> */ f_tmpl<Y> ();
template<class T> void g_tmpl () {
SomeTrait<T>::type foo; // (E), ill-formed
SomeTrait<T>::NestedTrait<int>::type bar; // (F), ill-formed
foo.data<int> (); // (G), ill-formed
}
template<class T> void g_tmpl () {
typename SomeTrait<T>::type foo; // (G), legal
typename SomeTrait<T>::template NestedTrait<int>::type bar; // (H), legal
foo.template data<int> (); // (I), legal
}
namespace N {
template<class T>
struct X { };
}
N:: X<int> a; // ... legal
typename N::template X<int> b; // (K), legal
typename template X<int> c; // (L), ill-formed
// .------- the base-specifier-list
template<class T> // v
struct Derived : typename SomeTrait<T>::type /* <- ill-formed */ {
...
};
struct Base {
template<class T>
struct type { };
};
struct Derived : Base {
using Base::template type; // ill-formed
using Base::type; // legal
};
template< typename T > void foo( T& x, std::string str, int count )
{
// these names are looked up during the second phase
// when foo is instantiated and the type T is known
x.size(); // dependant name (non-type)
T::instance_count ; // dependant name (non-type)
typename T::iterator i ; // dependant name (type)
// during the first phase,
// T::instance_count is treated as a non-type (this is the default)
// the typename keyword specifies that T::iterator is to be treated as a type.
// these names are looked up during the first phase
std::string::size_type s ; // non-dependant name (type)
std::string::npos ; // non-dependant name (non-type)
str.empty() ; // non-dependant name (non-type)
count ; // non-dependant name (non-type)
}
class A { public: typedef int type; static const int val { 1 }; };
class B { public: typedef float type; static const int val { 2 }; };
template<typename T> class C {};
template<int I> class D {};
template<typename T> class X {
T::type v; // OK
T::type f(T::type arg) { return arg; } // OK
T::type g(double arg) { return static_cast<T::type>(arg); } // OK
// C<T::type> c1; // error
D<T::val> d; // OK (as has always been)
C<typename T::type> c2; // OK (old style)
typedef T::type mytype; // OK
using mytypeagain = T::type; // OK
C<mytype> c3; // OK (via typedef / using)
};
X<A> xa;
X<B> xb;
template <class T>
struct DependentType
{
typename T::type a;
using Type=typename T::type;
};
template <class T>
struct DependentTemplate
{
// template function
template <class U>
static void func() {}
// template class
template <class U>
struct ClassName{};
};
template <class T1, class T2>
void foo()
{
// 3 ways to call a dependent template function
DependentTemplate<T1>::template func<T2>();
DependentTemplate<T1>().template func<T2>();
(new DependentTemplate<T1>())->template func<T2>();
// You need both typename and template to reference a dependent template class
typename DependentTemplate<T1>::template ClassName<T2> obj;
using Type=typename DependentTemplate<T1>::template ClassName<T2>;
}