C++泛型编程：模版

最新推荐文章于 2024-09-27 11:26:03 发布
最新推荐文章于 2024-09-27 11:26:03 发布
阅读量1k 收藏 19
点赞数 17
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangchen_0/article/details/142386902
版权

引言        

泛型编程（Generic Programming）是一种编程范式，允许编写与类型无关的代码，从而使程序更加灵活和可重用。在C++中，泛型编程主要通过模板（Templates）来实现。模板使得我们可以编写通用函数和类，从而在不同类型之间复用相同的算法或逻辑。这样，程序的灵活性和可扩展性得到了极大的提升。

例如一个交换函数，我们可能由于不同的参数类型，要重载多个函数。

void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
void Swap(double& left, double& right)
{
double temp = left;
left = right;
right = temp;
}
void Swap(char& left, char& right)
{
char temp = left;
left = right;
right = temp;
}

而c++的模版便是告诉编译器一个模子，让编译器根据不同的类型通过该模子来生成代码，只需要下面一段代码就能实现上面的所有功能

template<typename T>
T Add(const T& x, const T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

接下来，让我们一起来深入了解 C++ 模板的概念、用法以及一些高级特性吧。 

1.函数模版

函数模板允许我们创建一个可以处理不同类型参数的函数。

1.1基本语法

template <typename T>
T functionName(T arg1, T arg2) {
    // 函数体
}

 template <typename T>：定义一个模版，T是类型参数（类型参数可自定义）

T functionName (T arg1, T arg2)：函数返回类型和参数类型均为模板参数

1.2实例

隐式化实例：

#include <iostream>
using namespace std;
template<typename T>
T Add(const T& x, const T& y)
{
	return x + y;
}

int main()
{
	int a1 = 10;
	int a2 = 20;
	double b1 = 10.1;
	double b2 = 20.1;

	Add(a1, a2);
	Add(b1, b2);
	
	//没有与参数列表匹配的函数模版实例
	//Add(a1, b1);

	// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
	Add(a1, (int)b1);

	return 0;
}

显示化实例：在函数名后的<>中指定模版参数的实际类型

int main()
{
	int a1 = 10;
	double b1 = 10.1;

	Add<int>(a1, b1);

	return 0;
}

1.3模版参数匹配原则 

完全匹配优先，非模板函数优先

当调用模板时，编译器首先尝试找到与调用模版参数类型完全匹配的模版实例，如果非模板函数参数完全匹配，则优先选择非模板函数

// 专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
	return left + right;
}
void Test()
{
	Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
	Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

1.4函数模板默认参数

函数模板的默认参数是在函数模板定义中为模板参数指定的默认值。当使用函数模板时，如果没有为相应的模板参数提供具体的值，就会使用默认参数。
以下是一个函数模板默认参数的示例：

#include <iostream>
using namespace std;

template<typename T = int, int N = 10>
void printArray(T arr[]) {
    for (int i = 0; i < N; i++) {
        cout << arr[i] << " ";
    }
    cout << std::endl;
}

int main() {
    int intArray[] = {1, 2, 3, 4, 5};
    printArray(intArray); // 使用默认参数，T 为 int，N 为 10

    double doubleArray[] = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7};
    printArray<double, 7>(doubleArray); // 显式指定模板参数，T 为 double，N 为 7

    return 0;
}


在这个例子中，函数模板 printArray 有两个模板参数 T 和 N ，分别表示数组元素的类型和数组的大小。 T 的默认类型是 int ， N 的默认值是 10 。
 
需要注意的是，函数模板默认参数的指定应该遵循一定的规则：
 
1. 默认参数只能从右向左依次提供，即如果某个模板参数有默认参数，那么它右边的所有模板参数也必须有默认参数。
2. 在函数模板调用时，如果要为某个模板参数提供具体的值，那么它左边的所有模板参数也必须显式地指定。

2.类模版

类模板允许我们创建可以处理任意数据类型的类。

2.1类模板的基本语法

类模板的语法类似于函数模板。我们通过template关键字引入类型参数（或其他参数），以定义一个类模板。常见的形式是：

template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};

这里的T是一个模板参数，表示将来可以用来替代任何类型。Class类中的成员变量、构造函数和成员函数都使用模板参数T，因此该类可以处理不同类型的数据。

2.2实例

// 类模版
template<typename T>
class Stack
{
public:
     Stack(size_t capacity = 4)
    {
      _array = new T[capacity];
      _capacity = capacity;
      _size = 0;
    }
void Push(const T& data);
private:
      T* _array;
      size_t _capacity;
      size_t _size;
};

2.3非类型模板参数

除了类型参数外，类模板还可以接受非类型的模板参数。非类型参数通常用于定义与类型无关的值，例如数组的大小、常量等。例子如下：

template<typename T, int Size>
class Array {
private:
    T arr[Size];
public:
    Array() {
        for (int i = 0; i < Size; ++i) {
            arr[i] = 0;
        }
    }
    T& operator[](int index) {
        return arr[index];
    }
    int getSize() const {
        return Size;
    }
};

在这里，`Array`类模板接受一个类型参数`T`和一个整数参数`Size`，用于定义数组的大小。该模板可以实例化不同类型和大小的数组。

使用方式：

int main() {
    Array<int, 5> intArray;  // 定义一个包含 5 个 int 元素的数组
    intArray[0] = 10;
    std::cout << intArray[0] << std::endl;  // 输出 10
    std::cout << "Size: " << intArray.getSize() << std::endl;  // 输出 5
}

2.4. 类模板的默认参数

类模板和函数模板一样，也可以为模板参数提供默认值。

template<typename T = int>
class MyClass {
private:
	T value;
public:
	MyClass(T v) 
		: value(v) 
	{}
	T getValue() const 
	{ 
		return value; 
	}
};

int main() {
	MyClass<> obj(10); // 使用默认的 int 类型
	std::cout << obj.getValue() << std::endl; // 输出 10
}

在这里，如果没有提供模板参数，MyClass会默认使用int类型

需要注意的是，类模板默认参数的指定也要遵循一定的规则：
 
1. 默认参数只能从右向左依次提供，即如果某个模板参数有默认参数，那么它右边的所有模板参数也必须有默认参数。
2. 在函数模板调用时，如果要为某个模板参数提供具体的值，那么它左边的所有模板参数也必须显式地指定。

3.模板的特化

模板特化允许我们为特定类型定义不同于通用模板的特殊实现。当通用的模板定义不能满足某些特定类型的需求时，可以通过模板特化来提供专门的实现。类模板的特化分为完全特化和部分特化。

- 例如，假设有一个通用的模板函数用于比较两个值的大小：

template<typename T>
bool compare(T a, T b) {
    return a < b;
}

这个函数可以比较任何类型的值。但是，如果对于特定类型，如指针类型，需要不同的比较方式，可以进行模板特化：

template<>
bool compare<int*>(int* a, int* b) {
    return *a < *b;
}


在这个特化版本中，专门针对 int* 类型的指针进行了比较，比较的是指针所指向的值的大小，而不是指针本身的地址大小。 

3.1模板的完全特化

函数模板的完全特化：

函数模板的特化可以为某种具体类型提供定制的实现：

#include <iostream>

template<typename T>
void func(T value) {
    std::cout << "General template: " << value << std::endl;
}

// 完全特化，针对 char* 类型
template<>
void func<char*>(char* value) {
    std::cout << "Specialized for char*: " << value << std::endl;
}

int main() {
    func(10);           // 调用通用模板，输出 "General template: 10"
    func("Hello");      // 调用特化版本，输出 "Specialized for char*: Hello"
}


在这个例子中，函数模板被特化为char*类型，并为该类型提供了不同的实现。

类模板的完全特化：

类模板的完全特化是针对某一特定类型提供特殊的实现。例如，我们为bool类型特化一个类模板：

template<typename T>
class MyClass {
public:
    void print() {
        std::cout << "General template\n";
    }
};

// 针对 bool 类型进行完全特化
template<>
class MyClass<bool> {
public:
    void print() {
        std::cout << "Specialized for bool\n";
    }
};

int main() {
    MyClass<int> obj1;
    obj1.print();  // 输出 General template

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

在这个例子中，当模板参数为bool时，调用特化版本，而其他类型调用通用模板。

3.2模板的部分特化

部分特化是指特化模板的某些参数，而不是全部参数。类模板可以进行部分特化，但函数模板不能进行部分特化。

（1）类模板的部分特化

#include <iostream>

// 通用模板
template<typename T, typename U>
class MyClass {
public:
    void display() {
        std::cout << "General template\n";
    }
};

// 部分特化，当第二个参数是 int 时
template<typename T>
class MyClass<T, int> {
public:
    void display() {
        std::cout << "Partially specialized template for second parameter int\n";
    }
};

int main() {
    MyClass<double, double> obj1;
    obj1.display();  // 输出 "General template"

    MyClass<double, int> obj2;
    obj2.display();  // 输出 "Partially specialized template for second parameter int"
}

在这个例子中，当第二个模板参数为int时，会使用特化的模板。其他类型组合仍然使用通用模板。

（2）指针和引用的部分特化

部分特化还可以用于特定的类型模式，例如指针或引用类型。如下例：

#include <iostream>

// 通用模板
template<typename T>
class MyClass {
public:
    void display() {
        std::cout << "General template\n";
    }
};

// 部分特化，针对指针类型
template<typename T>
class MyClass<T*> {
public:
    void display() {
        std::cout << "Specialized template for pointer types\n";
    }
};

int main() {
    MyClass<int> obj1;
    obj1.display();  // 输出 "General template"

    MyClass<int*> obj2;
    obj2.display();  // 输出 "Specialized template for pointer types"
}

在这个例子中，MyClass<int*>会匹配到特化的指针类型版本，而MyClass<int>仍然使用通用模板。

3.3. 模板特化与继承

- 在 C++中，可以结合模板和继承来创建更加灵活和可扩展的类层次结构。通过模板参数，可以在基类中定义一些通用的功能，而派生类可以根据具体的需求进行特化或扩展。
- 例如，考虑一个通用的容器类模板：

template<typename T>
class Container {
public:
    void add(T item) {
        // 添加元素到容器的通用实现
    }
    // 其他通用的容器操作
};

然后，可以创建一个派生类来特化这个容器类，例如一个只存储整数的容器：

class IntContainer : public Container<int> {
public:
    // 可以添加针对整数容器的特殊操作
};

在这个例子中， IntContainer 继承自 Container<int> ，继承了通用容器类的功能，并可以根据整数的特点添加特定的操作。

#include <iostream>
using namespace std;
template<typename T>
class Base {
public:
    void print() {
        cout << "Base template\n";
    }
};

// 特化 Base 类，针对 int 类型
template<>
class Base<int> {
public:
    void print() {
        cout << "Specialized Base template for int\n";
    }
};

template<typename T>
class Derived : public Base<T> {
public:
    void show() {
        cout << "Derived template\n";
        this->print();
    }
};

int main() {
    Derived<double> obj1;
    obj1.show();  // 调用通用模板，输出 "Base template"

    Derived<int> obj2;
    obj2.show();  // 调用特化模板，输出 "Specialized Base template for int"
}

在这个例子中，基类Base<int>进行了完全特化，当派生类继承自Base<int>时，它将使用特化版本的print()函数，而其他类型使用通用版本。

4. 模板特化的应用场景

模板特化通常用于以下场景：

- 处理某些类型的特殊需求：例如，对bool类型、指针类型、数组类型等进行特殊处理。
- 针对容器或算法进行优化：在某些类型上进行优化以提高性能，例如对于std::vector<bool>的特殊优化。
- 处理特定类型的不同行为：例如，针对浮点数和整数提供不同的处理逻辑。
  

模板特化是C++泛型编程中非常强大且灵活的特性。通过模板特化，程序员可以为某些类型提供特定的处理方式，而不影响其他类型的通用逻辑。理解和合理使用模板特化可以让代码更加高效、灵活。

舞武零落
关注
C++泛型编程
蹦跶跶
06-04 6407
C++泛型编程与STL总结1. 泛型编程1.1 模板1.2 函数模板1.2.1 语法1.2.2 使用函数模板方式1.2.3 普通函数和函数模板的区别1.2.4 普通函数与函数模板的调用规则1.2.5 模板的局限性1.3 类模板2. STL技术 1. 泛型编程 泛型编程最初诞生于C++中。目的是为了实现C++的STL（标准模板库）。其语言支持机制就是模板（Templates）。模板的精神其实很简单：参数化类型。换句话说，把一个原本特定于某个类型的算法或类当中的类型信息抽掉，抽出来做成模板参数T。（参考自Bai
C++泛型编程：源起、实现与意义 免积分
02-28
### C++泛型编程：源起、实现与意义 #### 泛型编程的起源与动机 泛型编程的概念源于一种需求：开发一个通用且高效的标准容器库，这种库能够存储不同类型的对象，同时保证类型安全性和性能优势。C++作为一种强大的...
C++泛型编程：模板偏特化
暮色年华的博客
02-06 176
我们可以指定一部分模板参数的具体类型，或对模板参数施加一些约束条件。类型时，我们希望有一个特殊的实现。这时，可以使用模板偏特化来实现。模板偏特化为模板提供特殊的实现，针对特定的模板参数或参数组合。在模板全特化，所有的模板参数都被指定了具体的类型。我们可以在泛化设计中提供一个特化版本。假设有一个类模板，有两个模板参数。假设当第二个模板参数是。
C++ | 泛型编程：模板初阶与函数模板深度解析
TTKunn的博客
09-02 1950
本文主要讲解C++泛型编程中关于模板初阶与函数模板的深度解析
C++ 泛型编程
zy1872071381的博客
08-26 704
C++泛型编程
【C++】泛型编程与模板
qq_73758702的博客
04-12 773
C++ 模板（Template）是 C++ 语言提供的一种泛型编程机制，允许编写独立于具体数据类型的代码。模板可以用于函数和类，分别称为函数模板和类模板。
C++ 泛型编程：函数模板
wuyiyu_的博客
08-13 606
当需要编写通用的代码以处理不同类型的数据时，C++ 中的函数模板是一个很有用的工具。函数模板允许我们编写一个通用的函数定义，可以用于多种不同的数据类型，从而提高代码的重用性和灵活性。泛型编程是一种编程范式，旨在实现可重用、通用性高的代码。它允许我们编写与特定数据类型无关的代码，使代码能够适用于多种不同的数据类型。传统的编程方法主要依赖于特定的数据类型，需要为每个数据类型编写特定的代码。在泛型编程中，我们使用泛型类型来表示不特定的数据类型，可以在代码中使用泛型类型作为参数、变量或返回类型。
详解C++中的泛型编程及模版
weixin_67526434的博客
07-02 761
详细介绍一下C++中的泛型编程思想及模版
C++新经典模板与泛型编程：元编程，这是一个神秘而且牛逼的技术，c++性能提升有《effective C++》，《more effective C++》等等，但是这个技术才真正属于牛逼plus们的绝技
the growth of Nick
12-06 425
typelisttupleBoost库MPLGitHubMPL 11元编程库C++ 11BoostMPL。
探索C/C++泛型编程：原理、使用方法和应用场景
深耕嵌入式领用多年， 致力于分享嵌入式领域技术!
04-25 549
探索C/C++泛型编程：原理、使用方法和应用场景
【C++】C++泛型编程 | 模板初阶
Welcome home | Jian Liao 's blog
05-20 976
🌀 本章给大家带来的是C++泛型编程—模板。C++是C语言的扩展，注重面向对象编程及泛型编程。泛型编程是一种基于参数化的编程方式，简单来说就是编写具有通用性，可以适用于不同类型数据的代码。模板就是C++中实现泛型编程的一种重要手段。🌀C++中的模板允许程序员编写一套泛型代码，可以适用于不同的数据类型，因此称之为“模板”。模板可以分为函数模板和类模板两种形式。函数模板可以让程序员编写一个通用的函数（函数的参数或返回值是泛型类型），可以适用于各种不同的数据类型。
C++程序设计与实践：11-模板和泛型编程.ppt
06-12
C++程序设计与实践：模板和泛型编程 C++ 程序设计与实践中，模板和泛型编程是非常重要的概念。模板是 C++ 的泛型机制，用来实现泛型编程。泛型编程是指不依赖于任何具体类型来编写通用代码，具体类型信息的提供是在...
深入浅出C++模板编程：泛型编程的强大力量.md
09-07
C++模板编程及其在泛型编程中的强大应用。首先，文章介绍了模板的基础概念，包括函数模板和类模板，讲解了模板参数的类型和非类型参数，以及模板实例化的过程。接着，文章阐述了模板编程的优势，如代码复用、类型...
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1004
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 987
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
pyqt瀑布流布局
weixin_54217201的博客
09-21 482
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
【C++】红黑树的封装——同时实现map和set
最新发布
Mesar的博客
09-27 553
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
Python对于C语言使用者来说的反直觉特性
m0_62710548的博客
09-22 787
在编程领域，从一种语言转向另一种语言总是伴随着一系列的学习和调整。对于习惯了C语言严谨性的程序员来说，转向Python可能会遇到一些令人惊讶的特性。以下是我在短暂学习了一段时间python后察觉到的一些python的特性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值