在模板,在那里,为什么我必须把typename和template上依赖的名字呢？究竟什么是依赖名称？我有以下代码:
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 …在C++中定义函数模板或类模板时,可以这样写:
template <class T> ...
或者可以这样写:
template <typename T> ...
是否有充分理由偏好一个而不是另一个？
我接受了最受欢迎(也很有趣)的答案,但真正的答案似乎是"不,没有理由偏爱另一个."
typename.class.但是,请注意,在模板模板参数的情况下,需要使用class而不是typename.请参阅下面的user1428839的答案.(但这个特殊情况不是偏好问题,而是语言的要求.)(这也会改变typename)
我已经用C++编程了几年,我已经使用了很多STL并且已经创建了我自己的模板类几次以了解它是如何完成的.
现在我正在尝试将模板更深入地集成到我的OO设计中,一个唠叨的想法不断回到我身边:它们只是一个宏,真的......你可以使用#defines实现(而不是UGLY)auto_ptrs,如果你真的想要.
这种思考模板的方式有助于我理解我的代码将如何实际工作,但我觉得我必须以某种方式忽略这一点.宏是邪恶的化身,但"模板元编程"风靡一时.
那么,真正的区别是什么？模板如何避免#define引导你进入的危险,比如
template <typename T> 和之间的区别是什么template <class T>.对我来说,两者都产生了相同的结果.
例如
template <class T>
T Average(T *atArray, int nNumValues)
{
T tSum = 0;
for (int nCount=0; nCount < nNumValues; nCount++)
tSum += atArray[nCount];
tSum /= nNumValues;
return tSum;
}
如果我把它改成它 template <typename T>就是一样的
我想出了一个定义一个通用比较运算符的想法,它可以用于任何类型,以获得它的乐趣.
#include <cstring>
#include <iostream>
class A
{
public:
A(int id) : id(id) {}
private:
int id;
};
template <class T>
inline bool operator==(const T& a, const T& b)
{
return memcmp(&a, &b, sizeof(a)) == 0; // implementation is unimportant (can fail because of padding)
}
int main()
{
std::cout << (A(10) == A(10)) << std::endl; // 1
std::cout << (A(10) == A(15)) << std::endl; // 0
}
我认为这可以用来解决c ++中缺少默认比较运算符的问题.
这是一个糟糕的主意吗？我想知道在某些情况下这样做是否会破坏任何东西？
以下两种方式在c ++中编写模板有什么区别
template<typename T> & template<class T>
我们什么时候比他们更喜欢他们？如果两者都相同,那么为什么如果一个就够了我们两个都有？
我可以处理移植平台相关的功能.我有一个问题,我在Linux上尝试的编译器(clang和g ++)不接受以下代码,而msvc ++编译器执行:
template <class T>
class Base {
protected:
T Value;
};
template <class T>
class Derived : public Base<T> {
public:
void setValue(const T& inValue){
Value = inValue;
}
};
int main(int argc, char const *argv[])
{
Derived<int> tmp;
tmp.setValue(0);
return 0;
}
g ++错误:
main.cpp: In member function ‘void Derived<T>::setValue(const T&)’:
main.cpp:11:3: error: ‘Value’ was not declared in this scope
我相信这是由于Value在第二类中使用了非依赖名称().更多信息.
问题是我有一个非常大的代码库,其中经常使用这种类型的代码.我明白看标准时错了.然而,不必写this->或Base<T>::在每次使用前都非常方便Value.using Base<T>::Value;当你使用~20个基类成员时,即使在派生类的开头写作也是有问题的.
所以我的问题是:是否有适用于Linux的编译器允许这种代码(有或没有额外的编译器开关)？或者是否有一些小 …
我正在阅读Generic Classes主题.我一度陷入困境.以下是一段代码
template <class StackType> class stack
{
StackType stck[10];
int tos;
public:
stack() {tos=0;}
void push(StackType ob);
StackType pop();
};
我的问题是template <class StackType> class stack,有两个类(StackType和stack)？
我的意思是编译器如何将其视为使堆栈成为StackType的嵌套类或其他东西？
我最近开始使用C++ 11,并且对class关键字的特殊用法有一些问题.我知道它用于声明一个类,但有两个我看到的实例,我不明白:
Method<class T>();
和
class class_name *var;
为什么我们在第一个示例中使用关键字class在typename之前,并且第二个示例中的关键字是什么？
上下文:
我们正在尝试建立一个名为Operand的类模板,它可以将几种类型作为其类型名称T.这些在以下枚举中定义:
enum eOperandType {
INT8
INT16,
INT32,
FLOAT,
DOUBLE
};
那些对应于定义的类型<cstdint>,即int8_t, int16_t,等等.
构造函数必须是Operand(std::string const & value);.
template<class T>
class Operand : public IOperand
{
public:
Operand(std::string const & value)
{
std::stringstream ss(value);
ss >> _value;
//_type = ??? ;
}
[...]
private:
Operand(void){}
eOperandType _type;
T _value;
};
接口IOperand在这里并不重要,只是运算符重载的一些原型.
问题:
设置_type属性的最佳方法是什么？最简单的办法是只写几个if/else if用typeid或接近的东西,但我觉得这将是非常脏.此外,我只是认为typeid在模板内部使用只是意味着你在某处做错了什么......对吗？