C++如何使用模板实现泛型工具函数

template <typename T>

template <class T>

T

T

#include <iostream>
#include <string> // 引入string以便测试

// 泛型最大值函数模板
template <typename T>
T myMax(T a, T b) {
    // 这里使用了三元运算符，简单明了
    return (a > b) ? a : b;
}

// 另一个泛型函数示例：交换两个变量的值
template <typename U>
void mySwap(U& a, U& b) {
    U temp = a;
    a = b;
    b = temp;
}

int main() {
    // 测试myMax
    int i1 = 5, i2 = 10;
    std::cout << "Max of " << i1 << " and " << i2 << " is: " << myMax(i1, i2) << std::endl; // 实例化为myMax<int>

    double d1 = 3.14, d2 = 2.71;
    std::cout << "Max of " << d1 << " and " << d2 << " is: " << myMax(d1, d2) << std::endl; // 实例化为myMax<double>

    std::string s1 = "apple", s2 = "banana";
    std::cout << "Max of \"" << s1 << "\" and \"" << s2 << "\" is: " << myMax(s1, s2) << std::endl; // 实例化为myMax<std::string>

    std::cout << "--------------------" << std::endl;

    // 测试mySwap
    int x = 100, y = 200;
    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;
    mySwap(x, y); // 实例化为mySwap<int>
    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;

    double p = 1.23, q = 4.56;
    std::cout << "Before swap: p = " << p << ", q = " << q << std::endl;
    mySwap(p, q); // 实例化为mySwap<double>
    std::cout << "After swap: p = " << p << ", q = " << q << std::endl;

    return 0;
}

myMax

mySwap

T

U

main

int

double

std::string

template <typename T, typename U>

int

double

std::string

Person

void*

operator<

std::enable_if

std::enable_if

#include <type_traits> // 包含类型特性库

// C++11/14/17 风格的 SFINAE 约束
template <typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type // 只有当T是整数类型时，这个函数才有效
processIntegral(T value) {
    std::cout << "Processing integral value: " << value << std::endl;
}

// 另一个SFINAE示例，限制只有可比较的类型
template <typename T>
typename std::enable_if<std::is_arithmetic<T>::value && std::is_scalar<T>::value, T>::type
getAbsolute(T value) {
    return (value < 0) ? -value : value;
}

// C++14/17 可以使用 `_t` 后缀简化 `typename std::enable_if<...>::type`
template <typename T>
std::enable_if_t<std::is_floating_point<T>::value, void>
processFloatingPoint(T value) {
    std::cout << "Processing floating point value: " << value << std::endl;
}

#include <concepts> // 包含C++20 Concepts库
#include <iostream>
#include <string>

// 定义一个概念：要求类型是可打印的（这里简化为支持<<操作符）
template <typename T>
concept Printable = requires(T a) {
    { std::cout << a } -> std::ostream&; // 要求表达式 std::cout << a 是合法的，并且返回 std::ostream&
};

// 使用Concepts约束泛型函数
template <Printable T> // 只有满足Printable概念的类型才能调用这个函数
void printValue(T value) {
    std::cout << "Value: " << value << std::endl;
}

// 另一个概念：要求类型是算术类型
template <typename T>
concept Arithmetic = std::is_arithmetic_v<T>;

template <Arithmetic T> // 只有算术类型才能调用
T multiplyByTwo(T value) {
    return value * 2;
}

int main() {
    printValue(123);
    printValue(3.14);
    printValue(std::string("Hello Concepts!"));

    // printValue(std::vector<int>{1,2,3}); // 这会编译失败，因为std::vector<int>不满足Printable概念，编译器会给出清晰的错误

    std::cout << "Multiplied by two: " << multiplyByTwo(5) << std::endl;
    std::cout << "Multiplied by two: " << multiplyByTwo(2.5) << std::endl;
    // multiplyByTwo(std::string("abc")); // 这也会编译失败

    // 另外，对于一些简单的编译期检查，我们还可以使用 static_assert
    static_assert(sizeof(int) >= 4, "int must be at least 4 bytes on this platform!");
    static_assert(std::is_same_v<decltype(1+1), int>, "1+1 should be an int!");

    return 0;
}

static_assert

static_assert