我已经用C++编程几年了，使用STL相当多，并且创建过自己的模板类来查看其工作方式。
现在我正在尝试将模板更深入地集成到我的OO设计中，并且总有一个令人讨厌的想法萦绕在我脑海里：它们只是宏，真的...如果您真的想这样做，可以使用#define实现（相当丑陋的）auto_ptrs。
这种关于模板的思考方式帮助我理解我的代码实际上将如何工作，但我感觉我一定某些方面上错了。宏被认为是邪恶的化身，然而“模板元编程”却非常流行。
那么，真正的区别是什么？模板如何避免#定义引导您进入的危险，比如：
宏是一种文本替换机制。
模板是一种在编译时执行并集成到C++类型系统中的功能图灵完备语言。您可以将其视为语言的插件机制。
这些代码被编译器解析，而不是在编译器之前运行的预处理器解析。
MSDN对此的解释如下： http://msdn.microsoft.com/en-us/library/aa903548(VS.71).aspx
以下是宏的一些问题：
- 编译器无法验证宏参数是否具有兼容类型。
- 该宏会在没有任何特殊类型检查的情况下展开。
- i和j参数将被评估两次。例如，如果任何一个参数具有后增变量，则增量将执行两次。
- 由于宏是由预处理器展开的，因此编译器错误消息将引用展开的宏，而不是宏定义本身。此外，在调试期间，该宏也将以展开形式显示。
如果这还不足够让你明白，那我也不知道什么能让你明白了。
这里有很多评论试图区分宏和模板。
是的，它们都是同样的东西：代码生成工具。
宏是一种原始形式，没有太多的编译器强制执行（就像在 C 中使用对象一样 - 可以做到，但不好看）。 模板更先进，并且具有更好的编译器类型检查、错误消息等功能。
然而，每种方法都有其优点。
模板只能生成动态类类型 - 宏可以生成几乎任何你想要的代码（除了另一个宏定义）。 宏非常有用，可以将结构化数据的静态表嵌入到您的代码中。
另一方面，模板可以实现一些真正奇特的事情，这是宏所不能实现的。例如：
template<int d,int t> class Unit
{
double value;
public:
Unit(double n)
{
value = n;
}
Unit<d,t> operator+(Unit<d,t> n)
{
return Unit<d,t>(value + n.value);
}
Unit<d,t> operator-(Unit<d,t> n)
{
return Unit<d,t>(value - n.value);
}
Unit<d,t> operator*(double n)
{
return Unit<d,t>(value * n);
}
Unit<d,t> operator/(double n)
{
return Unit<d,t>(value / n);
}
Unit<d+d2,t+t2> operator*(Unit<d2,t2> n)
{
return Unit<d+d2,t+t2>(value * n.value);
}
Unit<d-d2,t-t2> operator/(Unit<d2,t2> n)
{
return Unit<d-d2,t-t2>(value / n.value);
}
etc....
};
#define Distance Unit<1,0>
#define Time Unit<0,1>
#define Second Time(1.0)
#define Meter Distance(1.0)
void foo()
{
Distance moved1 = 5 * Meter;
Distance moved2 = 10 * Meter;
Time time1 = 10 * Second;
Time time2 = 20 * Second;
if ((moved1 / time1) == (moved2 / time2))
printf("Same speed!");
}
模板允许编译器在运行时动态地创建和使用类型安全的模板实例。编译器实际上在编译时进行模板参数计算，为每个唯一结果需要创建单独的类。在条件语句中有一个隐含的Unit<1,-1>（距离/时间=速度）类型，在代码中从未明确声明。
显然，某个大学的某人已经定义了这种带有40多个参数的模板（需要参考），每个参数代表不同的物理单位类型。考虑一下这种类的类型安全性，仅就你的数字而言。
#define log(...) someLoggingFunction(__LINE__, __VA_ARGS__)。 - Aconcaguaint或float是否定义了operator+add<float>(5, 3);和add<int>(5, 3);可以有不同的实现方式，这在宏中是不可能的#define min(i, j) (((i) < (j)) ? (i) : (j)) - 参数i和j会被评估两次。例如，如果任何一个参数具有后增变量，则增量会执行两次注意：在一些罕见情况下，我更喜欢依赖可变参数宏，因为直到C++0x成为主流，才会有可变模板。 C++11已经发布。
参考资料：
从基础层面上来说，模板确实只是宏替换。但是如果你这样想就会忽略掉很多东西。
考虑模板特化，据我所知，你无法使用宏模拟它。这不仅允许对某些类型进行特殊实现，而且是模板元编程的关键部分之一：
template <typename T>
struct is_void
{
static const bool value = false;
}
template <>
struct is_void<void>
{
static const bool value = true;
}
这只是许多你可以做的事情之一的例子。模板本身就是图灵完备的。
这忽略了非常基础的东西，比如作用域、类型安全和宏更加混乱。
不行。一个简单的反例：模板遵循命名空间，宏会忽略命名空间（因为它们是预处理器语句）。
namespace foo {
template <class NumberType>
NumberType add(NumberType a, NumberType b)
{
return a+b;
}
#define ADD(x, y) ((x)+(y))
} // namespace foo
namespace logspace
{
// no problemo
template <class NumberType>
NumberType add(NumberType a, NumberType b)
{
return log(a)+log(b);
}
// redefintion: warning/error/bugs!
#define ADD(x, y) (log(x)+log(y))
} // namespace logspace
C++模板类似于Lisp宏（不是C宏），因为它们操作已解析的代码版本，并让您在编译时生成任意代码。不幸的是，您正在编写类似于原始Lambda演算的东西，因此像循环这样的高级技术有点麻烦。有关所有令人毛骨悚然的细节，请参见Krysztof Czarnecki和Ulrich Eisenecker的生成式编程。
如果你想更深入地了解这个主题，我可以向大家介绍一个众所周知的C++反对者。这个人比我更了解和憎恨C++，同时也使得FQA变得极具争议性并且是一种极佳的资源。
typename而言，要求非常简单。编译器不能总是确定依赖名称是引用类型还是其他类型。显式使用typename告诉编译器它是引用类型。struct X {
int x;
};
struct Y {
typedef long x;
};
template <class T>
class Z {
T::x;
};
Z<X>; // T::x == the int variable named x
Z<Y>; // T::x == a typedef for the type 'long'
typename关键字告诉编译器特定的名称意图是引用类型，而不是变量/值，所以您可以定义其他该类型的变量。
这些都非常重要，能够预防很多错误。