这些表达式都是普通类型的定义:
int num;
bool flag;
但是,一些看起来像普通类型定义的表达式意外地变成了模板的声明(详见下面和)!
下面是相关的代码片段():
#include<iostream>
template<typename T>
class Test
{
public:
static constexpr int sdm = T(nullptr);
static int f(void){static_assert(sizeof(T)==0);}
int g(
考虑以下代码:
//header.h
template<class T>
class A
{
static int x;
};
template<class T>
int A<T>::x = 0;
//source1.cpp
#include "header.h"
void f(){} // dummy function
//main.cpp
#include "header.h"
int main(){}
在本例中,代码编译完美,没有错误,但如果我从类中删除模板限定符
class A
{
static
在给定文件中,如果我有,
struct A { static int a; };
struct B { static int b; };
int A::a;
int B::b;
然后,我总是可以期待在B::b之前初始化A::a。现在对于相同的文件,以template为例,
template<typename T>
struct X { static T t; };
template<typename T>
T X<T>::t;
假设X是用A和B实例化的,并且它的static成员在代码中的某个地方被任意使用,如,X<A>::t和X<B>
我正在编写一个涉及类模板专门化的示例,其中我注意到该标准允许对数据成员进行两种不同的语法专门化,如下所示:
template<typename T >
struct C {
static int x;
};
template<>
struct C<bool> {
static int x;
};
//here we cannot write prefix template<>
int C<bool>::x = 0;
正如在上面的示例中所看到的,我们不允许为定义静态数据成员template<>编写前缀x。
template <typename T>
void foo(T t)
{
... // do stuff with type T
}
template <typename T>
class class_template
{
// class body
};
template<> // failed attempt at full specialization
void foo(class_template<T> t) // which doesn't work of c
在阅读的时候,我被下面的例子搞糊涂了:
// Example 2: Explicit specialization
//
template<class T> // (a) a base template
void f( T );
template<class T> // (b) a second base template, overloads (a)
void f( T* ); // (function templates can't be partially
// specialized
因此,我在泛型编程方面非常新,我开始了以下工作:
template<class T>
class A
{
public:
static int m;
}
template<class T>
int A<T>::m;
int main()
{
A::m = 3; //Cannot compile of course !!
return 1
}
这个想法是有一个成员变量,它可以被A的所有实例所共享,不管我们有什么T。
这样做有什么办法吗?还是我必须使用全局变量来代替?
已经有一些类似的问题已经在堆栈溢出上,但似乎没有直接回答我的问题。如果我转帖了,我真的很抱歉。
我想用这些方法的部分模板专门化来重载模板化类的一些方法(带有两个模板参数)。我还没能弄清楚正确的语法,我开始认为这是不可能的。我想我应该在这里发帖,看看能不能得到确认。
示例代码如下:
template <typename T, typename U>
class Test
{
public:
void Set( T t, U u );
T m_T;
U m_U;
};
// Fully templated method that should be use
class A
{
};
template <typename A, int S>
class B
{
public:
static int a[S];
B()
{
a[0] = 0;
}
};
template<> int B<A, 1>::a[1];
int main()
{
B<A, 1> t;
t;
}
在GCC 4.1下编译,但不链接:
static.cpp:(.text._ZN1BI1ALi1EEC1
我的一位同事告诉我,他和他的团队一起使用的一小块设计让我心烦意乱。这是一种特征类,他们可以以一种非常解耦的方式进行专门化。
我已经很难理解它是如何工作的,我仍然不确定我有什么想法,所以我想我会在这里寻求帮助。
我们在这里讨论的是g++,特别是3.4.2和4.3.2版本(这两者似乎都适用)。
这个想法很简单:
1-定义接口
// interface.h
template <class T>
struct Interface
{
void foo(); // the method is not implemented, it could not work if it was
};
我有以下问题,嵌套类(在本例中是struct)命名空间和返回类型
class Example
{
struct Node { /* with all the methods it needs */ }
Node * func();
}
现在,我想把func的实现放在类之外。所以我做的是:
Example::Node * Example::func()
{
return nullptr;
}
它工作得很好直到我做了example模板
template<typename T>
class Example {/* all the same here */}
template <t