为什么我们必须做模板<class/typename> T而不是模板T.
在C++中，模板的定义和使用需要使用<class/typename> T的形式，而不是直接使用T。这是因为C++的语言设计者为了解决模板的类型推导问题，以及为了避免与其他语言元素的混淆，决定使用<class/typename> T的形式来明确指出这是一个模板类型参数。
具体来说，<class/typename> T表示T是一个类型参数，而不是一个值参数或者其他类型的参数。这样，编译器就可以根据T的类型来推导出模板的实例化类型，从而实现模板的泛型编程。
例如，在定义一个模板类时，可以使用<class/typename> T来指定类型参数：
template<typename T>
class MyClass {
T data;
// ...
};在使用模板时，也需要使用<class/typename> T来指定模板参数的类型：
MyClass<int> myObj; // 使用int类型实例化模板类因此，我们必须使用<class/typename> T来定义和使用模板，以便编译器能够正确地推导出模板的实例化类型，并生成正确的代码。
相关·内容
1回答
这不是关于模板语法含义的问题，而是关于为什么C++标准委员会选择该语法的问题。让我们举个例子，
(1)
template< typename T>
Class A
{
...
}
上面是具有单个模板参数的类模板语法的语法。我可以理解这种语法是c++委员会可以任意选择的。
(2)
template<template <typename> typename T>
class B
{
...
}
C++标准委员会应该使用(1)和一些语言标准/语法来构建(2)语法。我无法理解(2)是如何使用(1)构建的。
如果给我一个选择，我会选择下面作为模板语法，
(3)
t
浏览 17提问于2020-05-17得票数 0
回答已采纳
2回答
我正在尝试理解一些C++语法：
template<class T>
class Foo
{
Foo();
template<class U>
Foo(const Foo<U>& other);
};
template<class T>
Foo<T>::Foo() { /*normal init*/ }
template<class T>
template<class U>
Foo<T>::Foo(const Foo<U>& other) { /*
浏览 5提问于2009-03-18得票数 1
回答已采纳
1回答
我不明白为什么以下这些失败了：
#include <cassert>
#include <memory>
#include <utility>
using namespace std;
template<typename... T> struct name{ static const char* value; };
template<typename... T> const char* name<T...>::value = "unknown";
template <> const cha
浏览 5提问于2014-10-18得票数 1
回答已采纳
3回答
首先，我要去上课准备这个测试：
struct Foo {
void test() {
std::cout << "test" << std::endl;
}
};
struct Bar {
Foo foo;
};
以及一个模板类，它在构造时接受指向成员的指针：
template<typename Type, typename MemberType>
class test {
public:
test(Type &t, MemberType Type::* p) : t(t) {
(t.*p).tes
浏览 11提问于2019-12-02得票数 0
我不太明白为什么下面的代码不是用g++编译的：
t.cpp: In instantiation of ‘Distrib<double>’:
t.cpp:28:56: instantiated from ‘Sampler<Distrib<Solution<double> > >’
t.cpp:35:48: instantiated from here
t.cpp:16:45: erreur: ‘double’ is not a class, struct, or union type
t.cpp:18:43: erreur: ‘double
浏览 0提问于2012-07-10得票数 5
回答已采纳
我的教授让我们学习这段代码，以更好地理解类模板在C++中是如何工作的，但我对第二行的含义感到困惑。我把两个星号(**)放在我希望得到更多澄清的声明旁边。
template<typename T>
Pair<T>::Pair(const T& firstVal, const T& secondVal) //**
{
first = firstVal;
second = secondVal;
}
这是Pair类模板：
template<typename T>
class Pair
{
public:
Pair();
浏览 3提问于2022-04-07得票数 1
假设我编写了一个带有模板构造函数的模板类，就像这样。
template<typename T>
class X{
template<typename S>
X(X<S> x){}
};
编译正常。但是，当我尝试在模板声明之外定义构造函数时，如下所示：
template<typename T>
class X{
template<typename S>
X(X<S> x);
};
template<typename T, typename S>
X<T>::
浏览 0提问于2012-08-17得票数 8
回答已采纳
4回答
我了解到可以通过以下方式使用模板创建数据结构：
template<typename T>
struct X {
T weight;
int age;
};
函数还可以通过以下方式使用模板：
template <class T>
T func_name(int age, T human) {
something_here;
}
其中一个区别是，在第一种情况下，我们使用typename，而在第二种情况下，我们使用class。
我发现包含以下内容的代码：
template<typename S, typename T>
bool is_null
浏览 5提问于2013-03-11得票数 1
非常奇怪的问题，我一直在努力在过去的几个小时(在解决5-6与SFINAE的其他问题，因为我是新手)。基本上，在下面的代码中，我希望f()可以处理所有可能的模板实例化，但只有在N == 2时才能使用N == 2。
#include <type_traits>
#include <iostream>
template<typename T, int N>
class A
{
public:
void f(void);
void g(void);
};
template<typename T, int N>
inline void
浏览 3提问于2017-01-27得票数 8
回答已采纳
1回答
我想在模板类中定义一些模板成员方法，如下所示：
template <typename T>
class CallSometing {
public:
void call (T tObj); // 1st
template <typename A>
void call (T tObj, A aObj); // 2nd
template <typename A>
template <typename B>
void call (T tObj, A aObj, B bObj); // 3rd
};
浏览 2提问于2010-08-30得票数 13
回答已采纳
1回答
两者有什么区别？
template <class T>
class why
{
public:
why()
{}
};
和
template <class T>
class why
{
public:
why<T>()
{}
};
它们的工作方式和编译方式似乎都是一样的。
编辑
而且，如果它们确实是相同的，为什么这种功能甚至在C++语言中也是如此？
浏览 6提问于2011-12-24得票数 1
回答已采纳
如果我们有一个标准的类：
class Foo {
public:
int fooVar = 10;
int getFooVar();
}
getFooVar()的实现将是：
int Foo::getFooVar() {
return fooVar;
}
但在模版类中：
template <class T>
class Bar {
public:
int barVar = 10;
int getBarVar();
}
getBarVar()的实现必须是：
template <class T>
int Bar
浏览 1提问于2018-12-03得票数 4
回答已采纳
我试图在头文件和使用专门化的实现之间划分一个模板类，但我希望一个方法只出现在某些专门化中。
头文件：
template <typename T>
class A
{
public:
void foo();
void bar();
template<typename U = T, typename std::enable_if<std::is_convertible<int,U>::value>::type* = nullptr>
void special();
};
执行情况：
template<typename T&
浏览 0提问于2019-08-27得票数 3
回答已采纳
1回答
类型成员C++的继承
、、、
我试图在它的子类中使用类的类型成员，但我失败了。特别是，我不明白为什么这段代码不编译：
template <typename T>
class A {
public:
using t = T;
A() {}
};
template <typename T>
class B: public A<T> {
public:
B() : A<T>() {}
A<T>::t foo(A<T>::t x) {
浏览 4提问于2021-06-24得票数 0
回答已采纳
考虑以下代码：
struct Test {
template <int S>
bool call();
};
template <>
bool Test::call<0>() {
return false;
}
template <>
bool Test::call<1>() {
return true;
}
template <int S, typename T>
static void func(T& t) {
t.call<S>();
}
int m
浏览 0提问于2013-11-04得票数 3
3回答
当依赖类型显示为基类时，我很惊讶地发现没有必要添加typename：
struct B {};
struct wr
{ typedef B type; };
template<class T>
struct A : T::type
{};
int main()
{
A<wr> a;
(void)a;
}
为什么在typename前面不需要T::type
浏览 1提问于2019-09-11得票数 25
回答已采纳
4回答
在C++中有两种模板类型(据我所知)：模板类和模板函数。为什么不可能有模板呢？(不管是类、函数或其他模板)。在标准中有没有考虑过这个问题？它是否在某种程度上破坏了C++的语法/精神？我知道这听起来很疯狂，而且很容易绕开。
使用C++可以实现什么：
template<bool b>
class TemplateDependingOnBool
{
public:
template<typename T>
class TheTemplateWeWant{};
}
最棒的是：
template<bool b>
template<typename T&g
浏览 6提问于2015-09-08得票数 3
回答已采纳
3回答
模板参数的替换失败
、、、、
我想要一个助手函数来为我实例化一个类。目前它不能用clang编译(虽然它是用gcc编写的)，但是我也需要它用clang编译。目前我正在使用clang version 6.0.0-1ubuntu2。
我不知道为什么会失败，因为gcc能够检测到这种类型。我试着用做一些事情，玩了一段时间，但我总是撞到墙上。可以使用MCVE，也可以在上试用
#include <vector>
using namespace std;
template <typename T, template <typename> typename Container>
struct Some
浏览 0提问于2019-03-09得票数 6
回答已采纳
我一直在阅读关于删除引用的类型，。
它给出了以下示例：
#include <iostream> // std::cout
#include <type_traits> // std::is_same
template<class T1, class T2>
void print_is_same() {
std::cout << std::is_same<T1, T2>() << '\n';
}
int main() {
std::cout << std::boolalpha;
浏览 5提问于2019-10-29得票数 10
回答已采纳
1回答
为什么我们需要BlobPtr的模板转发声明和模板的运算符重载。
template <typename> class BlobPtr;
template <typename> class Blob;
template <typename T>
bool operator==(const Blob<T>&, const Blob<T>&);
template <typename T>
class Blob {
friend class BlobPtr<T>;
fr
浏览 2提问于2021-06-07得票数 0
3回答
您能告诉我为什么会出现编译错误吗？
template<class T> class 'Node' used without template parameters
使用以下代码
template<class T>
class Node
{
private:
T _value;
vector<Node*> children;
public:
Node(T value);
Node<T>(c
浏览 0提问于2015-11-02得票数 0
2回答
我希望实现一个泛型方法，该方法可以对struct成员应用确定的操作，并将该成员作为参数传递。就像这样：
typedef struct Type_t{
int a;
double b;
} Type;
void gen_method(Type &t, TypeMember m){
t.m += 1;
}
我到现在为止所做的事：
typedef struct Type_t{
int a;
double b;
} Type;
typedef double Type::* PointerToTypeMemberDouble;
void gen_me
浏览 6提问于2016-04-19得票数 1
回答已采纳
非常直截了当：
template <class T>
void foo() {} //compiles
template <struct T>
void goo() {} //doesn't
为什么？
浏览 0提问于2012-03-13得票数 3
回答已采纳
1回答
在用g++编译以下代码时，我在“int”错误之前得到了一个“预期的主表达式”。你知道为什么怎么修吗？谢谢！
struct A
{
template <typename T>
T bar() { T t; return t;}
};
struct B : A
{
};
template <typename T>
void foo(T & t)
{
t.bar<int>();
}
int main()
{
B b;
foo(b);
}
浏览 4提问于2011-02-02得票数 3
1回答
如何检测调用结果是否有效？
、、、、
我正在尝试创建一个特征，用于检测哪种类型的Apply在调用时有一个有效的结果，其中包含了2个参数。我希望代码中的static_assert不会命中，因为apply的结果是有效的(除法浮点数)。为什么这个断言会命中，我将如何改变这个特性，使所有有效的应用重载都被检测为true_type或。
#include <type_traits>
#include <functional>
struct Apply
{
template<typename T1, typename T2>
float apply(const T1& a, cons
浏览 2提问于2020-04-03得票数 0
回答已采纳
我指定了如下所示的头文件：
04-Templates_foo.h:
template <typename T>
class foo {
T x, y;
T getX(void);
void setX(T x);
};
像这样的实现：
04-Templates_foo.cc:
#include "04-Templates_foo.h"
template <typename T>
T foo::getX(void) {
return this->x;
}
void foo::setX(T x) {
this
浏览 2提问于2013-11-20得票数 2
回答已采纳
1回答
template<typename T>class node{};
现在，如果我要在我的.hpp文件中使用以下模板定义
template<typename node<T>> class list{};
代码没有编译：
但如果我把定义改为
template<typename X> class list{};
并且在实例化过程中使用node<string>代替X，一切都很好。
我想了解为什么在第一种情况下代码不编译？AFAIK，node<T>本身就是一个独特的类型，就像X一样。
感谢你的想法。
浏览 0提问于2019-07-06得票数 0
回答已采纳
这段代码：
#include <memory>
template <template <typename> class Ptr>
class A { Ptr<int> ints; };
using B = A<std::unique_ptr>;
产生以下错误(使用GCC 6.3)：
a.cpp:6:28: error: type/value mismatch at argument 1 in template parameter list for ‘template<template<class> class P
浏览 3提问于2018-07-16得票数 5
2回答
函数签名专用模板
、、、
在测试代码中：
#include <string>
#include <iostream>
using namespace std;
template <typename T> class Signal;
template <typename T, typename U>
class Signal<T (U)>
{
public:
Signal<T (U)>(T (*ptr)(U))
{
}
};
void Print(string const& str)
{
cout << s
浏览 6提问于2012-12-15得票数 4
回答已采纳
5回答
让我举一个例子来说明我的问题：
template <typename T> class a{
public:
T data;
a():data(T()){}
a(T temp): data(temp) {}
};
所以如果用main()写
a(30);
a("String");
因此，根据模板参数演绎规则，它应该能够生成第一个临时类，如a<int>(30)等。
但我的错误是：
“(”令牌“之前缺少模板参数)
那么，为什么会发生这种情况，这只适用于函数模板？
浏览 4提问于2011-08-14得票数 0
回答已采纳
3回答
SFINAE未能处理中间类型性状
、、、、
考虑以下测试代码：
// Preprocessor
#include <iostream>
#include <type_traits>
// Structure with no type alias
template <class T>
struct invalid {
};
// Structure with a type alias
template <class T>
struct valid {
using type = T;
};
// Traits getting the type of the first type
浏览 0提问于2018-08-29得票数 1
回答已采纳
我正在写一个模板，我对此有点陌生。我注意到，我遇到的每个教程都在实现的每个函数之上声明了模板。我很好奇这是否有原因，是否有办法绕过它，以及它是如何有用的。
示例:在某些文件中(我们将称之为template.h)：
template <class T> class MyClass
{
public:
MyClass(T parameter);
T getParameter() const;
void setParameter();
void doSomethingUseless() const;
private:
T mParameter;
}
浏览 0提问于2016-06-23得票数 6
回答已采纳
考虑一组函数，如
template< class Fun >
void A( const Fun& )
{
}
template< class Fun >
void B( const Fun& )
{
}
template< class Fun >
void C( const Fun& )
{
}
设计为将函数类型作为参数。那么，这是完全可以的：
template< class T >
void Func( const T& )
{
}
A( Func< int > );
B( Func<
浏览 1提问于2012-07-25得票数 4
回答已采纳
当我想声明一个向量的迭代器时，为什么我需要使用typename？
例如：
typename vector<T>::iterator i;
如果我删除typename的关键字，那么程序就不能工作。我写的是：
#include <iostream>
#include <string>
#include <vector>
using namespace std;
template <class T>
class MyClass
{
private:
vector<T> array;
public:
浏览 6提问于2014-04-27得票数 0
2回答
递归变元模板不能导出参数
、、、
我有一个递归函数模板，内部使用类型'T‘，但变量模板参数仅用于生成递归模板。
int qi(int t) {
return 0;
}
template <typename T, typename... U>
int qi(int t) {
//do stuff...
return qi<U...>(t); // <--- error here
}
如果我试图编译它，就会得到错误could not deduce template argument for 'T'。为什么不能将函数推导成气的非模板变体(int qi(i
浏览 3提问于2015-07-09得票数 2
回答已采纳
1回答
具有部分专门化的类模板参数推断
、、、、
我很难理解新的C++17特性的所有限制，它允许在构造函数上进行模板推断。
特别是，此示例正确编译：
struct B {};
template <typename T, typename = T>
struct A {
A(T) {}
};
int main() {
B b;
A a(b); // ok
}
而这一条没有：
struct B {};
template <typename T, typename = T>
struct A;
template <typename T>
struct A<T> {
浏览 1提问于2017-09-08得票数 3
回答已采纳
可能重复：
早上好，我不明白，因为如果我将operator==作为成员函数实现为operator== (在类myList：：iterator中)，代码编译就会获得编译错误。
错误是
error: no match for operator== in it == it1
note: candidate is:
note: tempalte<class T> bool operator==(const typename myList<T>::iterator&,const typename myList<T>::iterator&)
守
浏览 5提问于2012-12-16得票数 2
我有一门课：
template <typename T>
class btree {
public:
btree(size_t maxNodeElems);
~btree() {}
struct node {
list <T> elements;
node *lvl;
};
private:
size_t maxNodeElems;
node* root;
};
template <typename T>
btree<T>::btree(siz
浏览 0提问于2011-10-19得票数 0
3回答
让我们假设我有以下类模板：
<> -读取为模板
template<template<class T> class Policy>
struct
{
};
如何(不向此<>添加额外的参数)向外部世界公开策略类型？
typedef不能工作，为什么我不能为loG写下这样的代码：
typedef Policy<T> Policy;
为什么我不能使用<< param>>中的T类型？此T类型不可访问吗？
浏览 2提问于2010-12-12得票数 2
回答已采纳
4回答
刚才我不得不深入网站找出为什么模板类模板成员函数会给出语法错误：
template<class C> class F00 {
template<typename T> bar();
};
...
Foo<C> f;
f.bar<T>(); // syntax error here
我现在意识到模板括号被视为关系运算符。要执行预期的操作，需要使用以下奇怪的语法: cf
f.template bar<T>();
你遇到过的C++/C++模板的其他奇怪的方面和陷阱是不是你认为是常识的？
浏览 0提问于2009-12-10得票数 23
1回答
我正在尝试获得一个嵌套模板类。
编译器给出了以下错误：
错误:模板类MyClass的模板参数列表中参数1处的类型/值不匹配--注意:期望一个类模板，得到‘SpecificType{ TemplateClass< Type1，Typ2，Type3 >}
这是我的密码
/* ...class definition... */
template < template < typename T1,typename T2,typename T3 > typename T>
class MyClass{
// is there a way to hav
浏览 2提问于2017-11-16得票数 1
回答已采纳
代码示例1：
namespace detail {
enum enabler { dummy };
}
class foo {
public:
template <typename T,
typename std::enable_if<!std::is_integral<T>::value,
detail::enabler>::type = detail::enabler::dummy>
void func(T t) {
浏览 3提问于2016-05-09得票数 13
回答已采纳
3回答
为什么我可以专门化类A，但不能专门化函数sum？我如何让这段代码工作呢？提前谢谢。
template<class T>
class A
{
};
template<class T>
class A<T*>
{
};
template<class T>
T sum(const T& a, const T& b)
{
return a + b;
}
template<class T>
T sum<T*> (const T* a, const T* b)
{
return *a + *b;
浏览 0提问于2013-07-13得票数 3
回答已采纳
2回答
我有这个模板
template <typename T, size_t maxsiz = 6>
class Array;
我有这个适配器模板
template <typename T, template <typename> class Container = std::vector>
class Stack;
我想做的是像这样在Stack中使用Array
Stack<int, Array> s;
但是，Array的默认构造函数不能满足Stack的要求，所以我需要专门为Array指定Stack。理想情况下，我只想专门化Stack<T, Ar
浏览 0提问于2015-04-28得票数 0
回答已采纳
2回答
我正在尝试创建一个模板类，使一个比较函数能够返回一个整数0-相等，>0a应该放在第一位，<0b应该放在第一位。
我使用排序结构模板参数来跟踪应该使用的类型、字符串中字段的偏移量以及该字段应保持的顺序.所以比较可以根据返回正确的值。
现在假设std::string用于表示序列化的值。
我在从模板中提取信息时遇到了困难。我将sort保留为pack参数，该参数的类型为Sort。如何访问代码中的这些参数？如果有更好的方法来重构这个。我查看了其他一些与模板相关的问题，但没有看到任何能够解决这个问题的问题。我使用gcc 8.2和c++17。
#include <cstdint>
#
浏览 0提问于2019-02-05得票数 1
回答已采纳
3回答
我正在与编译错误C3200作斗争
讨论了这个问题并给出了一个例子：
// C3200.cpp
template<typename T>
class X
{
};
template<template<typename U> class T1, typename T2>
class Y
{
};
int main()
{
Y<int, int> y; // C3200
}
并建议改为
Y<X, int> y;
必须使用。但我不太明白这一点。为什么不能呢？
Y<X<int>, int> y;
？这对我
浏览 0提问于2010-10-21得票数 0
回答已采纳
2回答
检查是否有有效的模板专门化
、、、、
我想检查一个模板是否可以使用给定的一组参数进行专门化。以下是只接受一个参数的模板的版本：
#include <iostream>
template<template<typename...> class C, typename T>
struct is_valid_specialization {
typedef struct { char _; } yes;
typedef struct { yes _[2]; } no;
template<template<typename...> class D, type
浏览 0提问于2014-01-29得票数 14
回答已采纳
考虑一下这段代码
#include <iostream>
#include <type_traits>
enum Thing {Thing0, Thing1, Thing2, NumThings};
enum Object {Object0, Object1, Object2, NumObjects};
template <Thing> struct ThingValue;
template <> struct ThingValue<Thing0> : std::integral_constant<int, 5> {
浏览 0提问于2015-06-19得票数 1
回答已采纳
3回答
我正在尝试创建一个函数，它将接受任何类型的list或vector
template <typename T>
void printSomething ( const T& v )
{
for( T::iterator i = v.begin(); i != v.end(); ++i )
{
std::cout << *i << std::endl;
}
}
我发现了一个错误：
error: need ‘typename’ before ‘T:: iterator’ because ‘T’ is a depend
浏览 19提问于2014-11-26得票数 0
回答已采纳
4回答
函数模板语法
template <**class** T, ...>
returntype functionname(arguments)
{
.....
.....
}
我有两个问题？
为什么要将模板参数声明为类类型？(即使用class关键字)，当我们将它声明为类类型时，编译器将做什么？
浏览 4提问于2012-04-22得票数 4
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
