C++ 之模板

类模板

在C++ 中，模板（Template）是一种通用的编程工具，允许程序员编写泛型代码，使得类或函数能够适用于多种不同的数据类型，而不需要编写相似的代码。C++提供了两种主要类型模板：类模板和函数模板。

类模板（class Templates）

类模板允许定义通用的类，其中某些类型可以作为参数。这样的类可以处理不同类的数据，而不需要为每个数据类型编写单独的类。

#include <iostream>

using namespace std;
template <typename T>
class PrintEvethint
{
private:
    T data;
public:
    void printEvethint()
    {
        cout << data << endl;
    }
    void setEvethint(T data)
    {
        this->data = data;
    }
};
int main()
{
    PrintEvethint<string> p1;
    p1.setEvethint("我是一个泛型");
    p1.printEvethint();
    return 0;
}

函数模板

函数模板运行编写通用的函数，可以处理多种不同类型的数据。

// 定义一个通用的函数模板
template <typename T>
T add(T a, T b) 
{
	return a + b;
}
int main() 
{
	// 使用函数模板调用通用函数
	int result1 = add(5, 10);
	double result2 = add(3.5, 2.7);

	// 输出函数模板调用结果
	std::cout << "Result 1: " << result1 << std::endl; // 输出 Result 1: 15
	std::cout << "Result 2: " << result2 << std::endl; // 输出 Result 2: 6.2
	return 0;
}

模板提供了一种在编写代码时更具通用性的方法，能够处理不同类型的数据而无需为每种类型编写特定的函数或类。通过使用模板，可以提高代码的重用性和可维护性。

模板特化

模板特化（Template Specialization）是 C++ 中模板的一个概念，它允许针对特定的数据类型或特定的模板参数提供定制化的实现。模板特化允许您为模板提供一个特殊的实现，以覆盖或扩展默认的模板行为。

有两种类型的模板特比：完全特化（Full Specialization）和部分特化（Partial Specialization）

完全特化（Full Specialization）

完全特化是对模板中的所有模板参数进行特化的情况。在完全特化中，模板参数被指定的类型，为特定的类型提供独特的实现。

以下是模板函数的完全特化：

#include <iostream>

// 定义一个通用的模板函数
template <typename T>
T maximum(T a, T b)
{
	return (a > b) ? a : b;
}
// 对模板函数进行完全特化，针对 char* 类型
template <>
const char* maximum<const char*>(const char* a, const char* b)
{
	return strcmp(a, b) > 0 ? a : b;
}
int main()
{
	int intMax = maximum(3, 5); // 调用模板函数
	std::cout << "Maximum of integers: " << intMax << std::endl;
	
	const char* charMax = maximum("apple", "orange"); // 调用特化的函数
	std::cout << "Maximum of strings: " << charMax << std::endl;
	return 0;
}

在这个示例中，maxmum 是一个模板函数，可以比较不同类型的数据，并返回较大的值。然后，为了特化针对const char * 类型，我们提供了一个特化版本的maximum函数，该函数使用strcmp函数来比较字符串，并返回较大的字符串。

部分特化（Partial Specialization）

部分特化是指对模板中部分参数进行特化，允许更具体地特化某些模板参数。这通常在模板类中使用。

以下是对模板类的部分特化

#include <iostream>
// 定义一个通用的模板类
template <typename T, typename U>
class MyTemplate 
{
public:
	void display()
	{
		std::cout << "Generic Display" << std::endl;
	}
};

// 对模板类进行部分特化，针对特定的类型组合
template <typename T>
class MyTemplate<T, int>
{
public:
	void display()
	{
		std::cout << "Specialized Display for T and int" << std::endl;
	}
}

int main()
{
	MyTemplate<float, double> obj1;
	obj1.display(); // 输出 "Generic Display"
	
	MyTemplate<int, int> obj2;
	obj2.display(); // 输出 "Specialized Display for T and int"
	return 0;
}

MyTemplate是一个模板类，然后我们对 MyTemplate进行部分特化，当第二个模板参数是int 类型时，提供了特殊的实现。因此，对于特定的类型组合，我们可以提供自定义实现。