template＜typename Func, typename = void＞在类模板中的应用

news2025/1/1 13:53:16

1、基础语法

在 C++ 中，template<typename Func, typename = void> 这一模板声明不仅仅限于函数模板，它在类模板中同样具有强大的应用。结合 SFINAE（Substitution Failure Is Not An Error）和类型特征（type traits），我们可以根据类型特征（如是否可调用、是否为某种类型等）来实现不同的类特化，从而使得我们的代码更加灵活、可扩展。
在类模板中，template<typename Func, typename = void> 的基本结构类似于函数模板，但其作用是为类提供更强的类型约束和灵活性。例如：

template<typename Func, typename = void>
class MyClass {
public:
    void call(Func&& f) {
        // Generic behavior
    }
};

这里，template<typename Func, typename = void> 表示 MyClass 是一个模板类，它接受一个类型参数 Func，第二个模板参数 = void 是默认值。该类可以根据不同类型的 Func 做出不同的行为，而 = void 通常用于与 SFINAE 机制配合，决定是否允许某些特定的类型实例化该类模板。

2、类模板的默认类型参数：简化和泛化

与函数模板类似，template<typename Func, typename = void> 在类模板中的一个常见用途是通过默认类型参数简化模板声明。我们通常使用第二个类型参数 = void 来启用某些特化或重载，这通常结合 SFINAE 使用。通过这种方式，模板类在默认情况下为某些类型提供通用行为，而在遇到特定类型时可以提供特化的行为。假设我们希望在类模板 MyClass 中提供一个 call 成员函数，当 Func 是可调用类型时，执行该函数，而如果 Func 不是可调用类型，则提供默认行为，代码如下：

#include <iostream>
#include <type_traits>

template<typename Func, typename = void>
class MyClass {
public:
    void call(Func&& f) {
        std::cout << "Generic version of call" << std::endl;
    }
};

// 特化版本：当 Func 是可调用类型时
template<typename Func>
class MyClass<Func, typename std::enable_if<std::is_invocable<Func>::value>::type> {
public:
    void call(Func&& f) {
        std::cout << "Callable function version of call" << std::endl;
        f(); // 执行传入的可调用对象
    }
};

void test_func() {
    std::cout << "test_func executed!" << std::endl;
}

int main() {
    MyClass<int> obj1;
    obj1.call(42);  // 输出: Generic version of call

    MyClass<void(*)()> obj2;
    obj2.call(test_func);  // 输出: Callable function version of call
                           //        test_func executed!
}

通用版本：当 Func 不是可调用类型时，MyClass<Func, typename = void> 使用默认版本的 call 函数输出 “Generic version of call”。
特化版本：当 Func 是可调用类型时，我们通过 std::enable_if 和 std::is_invocable 来限制模板实例化，使得编译器选择特化版本的 call，在这种情况下，我们可以直接调用 f() 来执行传入的可调用对象。

3、SFINAE：类模板中根据类型特征选择特化

template<typename Func, typename = void> 还常常与 SFINAE 结合使用来根据类型的不同提供不同的实现。SFINAE 机制允许在类型不匹配时，编译器不报错，而是选择其他合适的模板特化或重载版本。可以使用该技术根据类型特征提供不同的成员函数，我们将使用 std::is_integral 和 std::is_floating_point 类型特征来为整数类型和浮动类型提供不同的处理方法：

#include <iostream>
#include <type_traits>

template<typename T, typename = void>
class MyClass {
public:
    void print() {
        std::cout << "Generic version: Unknown type" << std::endl;
    }
};

// 特化版本：当 T 是整数类型时
template<typename T>
class MyClass<T, typename std::enable_if<std::is_integral<T>::value>::type> {
public:
    void print() {
        std::cout << "Integer version: " << sizeof(T) << " bytes" << std::endl;
    }
};

// 特化版本：当 T 是浮动类型时
template<typename T>
class MyClass<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
public:
    void print() {
        std::cout << "Floating point version: " << sizeof(T) << " bytes" << std::endl;
    }
};

int main() {
    MyClass<int> obj1;
    obj1.print();  // 输出: Integer version: 4 bytes

    MyClass<double> obj2;
    obj2.print();  // 输出: Floating point version: 8 bytes

    MyClass<std::string> obj3;
    obj3.print();  // 输出: Generic version: Unknown type
}

通用版本：对于非整数和非浮动类型，MyClass 使用通用版本的 print 成员函数。
整数类型特化：当 T 是整数类型时，使用特化版本的 print，输出整数类型的大小（以字节为单位）。
浮动类型特化：当 T 是浮动类型时，使用特化版本的 print，输出浮动类型的大小。

4、利用 = void 实现类型推导和重载

通过使用 template<typename Func, typename = void>，我们可以根据传入类型的特性来推导不同的行为。= void 作为一个默认模板参数可以帮助我们更好地控制模板重载和特化的匹配，尤其是在类模板中结合其他模板参数进行推导时。

#include <iostream>
#include <type_traits>

template<typename T, typename = void>
class MyClass {
public:
    void foo() {
        std::cout << "Generic version of foo" << std::endl;
    }
};

// 特化版本：当 T 是指针类型时
template<typename T>
class MyClass<T, typename std::enable_if<std::is_pointer<T>::value>::type> {
public:
    void foo() {
        std::cout << "Pointer type version of foo" << std::endl;
    }
};

int main() {
    MyClass<int> obj1;
    obj1.foo();  // 输出: Generic version of foo

    MyClass<int*> obj2;
    obj2.foo();  // 输出: Pointer type version of foo
}

通用版本：对于普通类型 T，MyClass 使用通用版本的 foo 成员函数。
指针类型特化：当 T 是指针类型时，MyClass 使用特化版本的 foo 成员函数。

5、结合 std::enable_if 和 std::is_same 实现类型限制

= void 还常常与 std::enable_if 和 std::is_same 等类型特征配合使用，限制模板类的实例化，提供更加灵活的行为。

#include <iostream>
#include <type_traits>

template<typename T, typename = void>
class MyClass {
public:
    void print() {
        std::cout << "Generic print" << std::endl;
    }
};

// 当 T 是 int 时，使用特化版本
template<typename T>
class MyClass<T, typename std::enable_if<std::is_same<T, int>::value>::type> {
public:
    void print() {
        std::cout << "Specialized print for int" << std::endl;
    }
};

int main() {
    MyClass<double> obj1;
    obj1.print();  // 输出: Generic print

    MyClass<int> obj2;
    obj2.print();  // 输出: Specialized print for int
}