作为 C++ 模板参数的类似函数签名的表达式

我在看唐·克拉格斯顿的快速委托迷你库并注意到一个奇怪的语法技巧，其结构如下：

TemplateClass< void( int, int ) > Object;

看起来好像函数签名被用作模板实例声明的参数。

这项技术（其在 FastDelegate 中的存在显然是由乔迪·哈金斯 (Jody Hagins) 发明的）用于简化具有半任意数量的模板参数的模板实例的声明。

也就是说，它允许这样的事情：

// A template with one parameter
template<typename _T1>
struct Object1
{
    _T1 m_member1;
};

// A template with two parameters
template<typename _T1, typename _T2>
struct Object2
{
    _T1 m_member1;
    _T2 m_member2;
};

// A forward declaration
template<typename _Signature>
struct Object;

// Some derived types using "function signature"-style template parameters
template<typename _Dummy, typename _T1>
struct Object<_Dummy(_T1)> : public Object1<_T1> {};

template<typename _Dummy, typename _T1, typename _T2>
struct Object<_Dummy(_T1, _T2)> : public Object2<_T1, _T2> {};

// A. "Vanilla" object declarations
Object1<int> IntObjectA;
Object2<int, char> IntCharObjectA;

// B. Nifty, but equivalent, object declarations
typedef void UnusedType;
Object< UnusedType(int) > IntObjectB;
Object< UnusedType(int, char) > IntCharObjectB;

// C. Even niftier, and still equivalent, object declarations
#define DeclareObject( ... ) Object< UnusedType( __VA_ARGS__ ) >
DeclareObject( int ) IntObjectC;
DeclareObject( int, char ) IntCharObjectC;

尽管确实有点黑客行为，但我发现这种对可变参数模板参数的欺骗性模拟相当令人兴奋。

这个技巧的真正要点似乎是我可以将诸如“Type1(Type2, Type3)”之类的文本结构作为参数传递给模板。所以这是我的问题：编译器到底如何解释这个结构？它是函数签名吗？或者，它只是一个带有括号的文本模式？如果是前者，那么这是否意味着就模板处理器而言，任何任意函数签名都是有效类型？

后续问题是，既然上面的代码示例是有效的代码，为什么 C++ 标准不允许您执行如下所示的操作，但该操作无法编译？

template<typename _T1>
struct Object
{
    _T1 m_member1;
};

// Note the class identifier is also "Object"
template<typename _T1, typename _T2>
struct Object
{
    _T1 m_member1;
    _T2 m_member2;
};

Object<int> IntObject;
Object<int, char> IntCharObject;

关于你的第一个问题 - 关于类型int(char, float)- 这是一个有效的 C++ 类型，并且是接受 a 的函数的类型char and a float并返回一个int。请注意，这是实际函数的类型，而不是函数指针，函数指针将是int (*) (char, float)。任何函数的实际类型都是这种不寻常的类型。例如，类型

void DoSomething() {
    /* ... */
}

is void ().

在例程编程中这种情况很少出现的原因是，在大多数情况下您无法声明这种类型的变量。例如，以下代码是非法的：

void MyFunction() { 
    void function() = DoSomething; // Error!
}

然而，您确实看到使用函数类型的一种情况是传递函数指针：

void MyFunction(void FunctionArgument()) {
     /* ... */
}

更常见的是，这种函数被编写为接受函数指针，但接受函数本身是完全可以的。它是在幕后制作的。

至于你的第二个问题，为什么用不同数量的参数编写相同的模板是非法的，我不知道规范中禁止它的确切措辞，但它与以下事实有关：一旦你声明了一个类模板，您不能更改它的参数数量。但是，您可以对具有不同数量参数的模板提供部分专业化，当然前提是部分专业化仅对原始参数数量进行专业化。例如：

template <typename T> class Function;
template <typename Arg, typename Ret> class Function<Ret (Arg)> { 
    /* ... */
};

Here, Function始终采用一个参数。模板特化接受两个参数，但特化仍然仅针对一种类型（具体来说，Ret (Arg)).