C++ 模版元编程 typename关键字介绍及

int ;

三、用法3.1 在常规场景中使用3.1.1 在函数参数中使用

当我们想要在函数参数中使用依赖类型时，我们需要。在这种情况下，用于明确指定该类型是从模板参数中派生出来的类型。例如：

template 
void function(typename T::SubType param);

在这个例子中，用于指定T::是一个类型。

3.1.2 在函数返回值中使用

和函数参数一样，我们也可以在函数的返回值类型中使用，用于明确地指出该类型是从模板参数中派生出来的。例如：

template 
typename T::SubType function();

在这个例子中，用于指定T::是函数的返回类型。

3.1.3 在类成员中使用

也可以在类模板中使用，用于指定成员的类型。例如：

template 
class MyClass {
    typename T::SubType member;
};

在这个例子中，用于指定T::是类成员的类型。

3.1.4 小结

下面是一个对于这四种使用 的方式的对比表：

使用场合

示例代码

描述

模板参数列表

void (T param);

在此处定义了 T 作为一个类型模板参数。

函数参数

void ( T:: param);

在此处明确指定 T:: 是从模板参数 T 中派生的类型。

函数返回值

T:: ();

在此处明确指定 T:: 是从模板参数 T 中派生的类型，并且是函数的返回类型。

类成员

class { T:: ; };

在此处明确指定 T:: 是从模板参数 T 中派生的类型，并且是类 的成员的类型。

3.2. 的其他使用场景3.2.1在模板参数列表中使用

C++ 中的 关键字在模板编程中有广泛的应用。让我们通过以下小节深入探讨其在不同场景下的用法。

在模板参数列表中，关键字用于表示类型模板参数。例如：

template 
void func(T param) {
    // ...
}

在这个示例中，T是一个类型模板参数。我们使用关键字来标记它。这样，当我们使用这个模板时，就可以将T替换为任意类型。例如：

func(10);  // T被替换为int
func(20.0);  // T被替换为double

在英语口语交流中，我们会这样叙述上述代码：“我们定义了一个模板函数func，其接收一个模板类型参数T。然后，我们通过调用func(10)和func(20.0)，分别将T替换为int和。”（We a func that takes a type T. Then, we func with T being int and by func(10) and func(20.0).)

3.3 在嵌套类型中使用

在模板编程中，我们经常需要处理嵌套类型（ Types）。这些类型通常是模板类中定义的类型，或者是模板参数类型的成员类型。在这种情况下，我们需要使用 关键字来显式地告诉编译器，我们正在处理一个类型而不是一个值。例如：

template 
void func() {
    typename T::NestedType object;
    // ...
}

在上述代码中，T:: 是一个嵌套类型，我们使用 关键字来表明这一点。这样，当我们使用模板时，就可以将 T:: 替换为任意嵌套类型。

在英语口语交流中，我们会这样叙述上述代码：“我们定义了一个模板函数 func，其使用 关键字来声明一个嵌套类型 T::。然后，我们可以在函数体内使用这个嵌套类型。”（We a func which uses to a type T::. Then, we can use this type the body.）

3.4 在模板特化和偏特化中的应用

模板特化和偏特化是 C++ 模板编程中常见的技巧。当我们需要对某些特定类型提供特殊的处理时，我们可以使用模板特化或偏特化。在这些场景中，我们可能需要使用 关键字。例如，假设我们有一个模板类 ，它有一个嵌套类型 ：

template 
class MyClass {
public:
    typedef T NestedType;
};

我们可以对 进行特化，特化时我们需要用到 关键字：

template 
class MyClass {
public:
    typedef int NestedType;
};

在这个特化版本的 中， 总是为 int 类型。我们使用 关键字来指定 的类型。

在下一节中，我们将探讨 在 std:: 中的应用，这是一个非常实用的技巧，可以让我们的模板代码更加灵活和强大。

3.3 在 std:: 中的应用

std:: 是一个常用于模板元编程的工具，它允许我们根据条件启用或禁用模板。在 std:: 中，我们通常需要使用 关键字。例如，假设我们有一个函数模板 func，我们想要只在 T 是整数类型时才使其可用，我们可以这样做：

template 
typename std::enable_if<std::is_integral::value>::type
func(T param) {
    // ...
}

在这个示例中，我们使用了 std::::value 来检查 T 是否为整数类型。如果是，则 std:: 将定义一个名为 type 的类型，否则 std:: 不定义任何类型。由于 关键字的存在，当 T 不是整数类型时，编译器将在编译时期就检测到这个错误，而不会产生错误的运行时行为。现在就好解释文章开头处那个std: 前的 的含义了：

template 
static typename std::enable_if<!std::is_void<typename std::result_of<
    F(Self, std::weak_ptr, Args...)>::type>::value>::type
call_member(const F &f, Self *self, std::weak_ptr ptr,
            std::string &result, std::tuple tp) {
  auto r = call_member_helper(
      f, self, typename nonstd::make_index_sequence{},
      std::move(tp), ptr);
  result = msgpack_codec::pack_args_str(result_code::OK, r);
}

3.3 的高级用法

在这个部分，我们将深入探讨的高级用法，包括多层语句，多条语句，以及与std::的组合应用。

3.3.1 多层语句

有时，我们需要使用多层嵌套的模板类型。在这种情况下，我们可能需要使用多层语句。让我们通过一个例子来看看如何使用多层语句：

template
class Outer {
public:
    template
    class Inner {};
};
template
void func(typename Outer::template Inner param) {
    // 实现细节...
}

template
class MyClass {
public:
    typedef T type1;
    typedef U type2;
};
template
void func(typename MyClass::type1 param1, typename MyClass::type2 param2) {
    // 实现细节...
}

template 
typename std::enable_if<std::is_integral::value, T>::type
process(T t) {
    std::cout << t << " is an integral number." << std::endl;
}

// 模板函数，同时使用模板参数列表、函数参数列表和函数返回值类型进行类型检查
template<
        typename T,  // 模板参数 T
        // 在模板参数列表中使用 typename 进行检查，T 必须是整型
        typename std::enable_if<std::is_integral::value>::type * = nullptr
// 在返回值类型中使用 typename 进行检查，T 的大小必须大于 4 字节
        typename std::enable_if 4), T>::type
        process(
            T value,  // 函数参数 value
            // 在函数参数列表中使用 typename 进行检查，T 必须是有符号类型
            typename std::enable_if<std::is_signed::value, T>::type * = nullptr
        ) {
    std::cout << value << " is an integral number, its size is greater than 4 bytes, and it is signed." <<
    std::endl;
    return
    value;
}
// 模板类，使用模板参数列表进行类型检查，T 必须是整型
template<
    typename T,  // 模板参数 T
    typename std::enable_if<std::is_integral::value>::type * = nullptr
    class MyClass {
    } ;
    
int main() {
    long l = 42;
    process(l);  // 此处可以成功编译和运行，因为 long 是整型，大于 4 字节，且是有符号类型
    // 下面的代码将无法编译，因为 unsigned long 不是有符号类型
    // unsigned long ul = 42;
    // process(ul);
    MyClass myClass;  // 成功实例化 MyClass，因为 int 是整型
    return 0;
}

template 
void function(typename T::subtype var) { // Do something with var. }

template 
class MyClass {
    T data[N];
};