C++笔记(十三): 泛型编程

最新推荐文章于 2024-07-15 14:33:37 发布
最新推荐文章于 2024-07-15 14:33:37 发布
阅读量176 收藏 1
点赞数
分类专栏： 自己的C++笔记 文章标签： c++ 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bobchen1017/article/details/128967499
版权
本文介绍了C++中的泛型编程，包括函数模板的使用，如自动类型推导和显示调用，以及类模板的定义和实例化。还讨论了模板的重载、特化（完全特化和部分特化）以及在继承中的应用。通过示例代码展示了模板在提高代码复用性和扩展性方面的作用。
摘要由CSDN通过智能技术生成

1. 导语

  1. 在C++里面不考虑具体数据类型的编程模式叫做泛型编程，泛型也是一种数据类型，是一种可以用来代替所有数据类型的通用类型
  2. 可以通过函数模版和类模版实现反省变成。

2. 函数模版的基本使用

  1. 简单看下函数模版的定义

  2. 函数模版的意义: 对类型也可以进行参数化了，不仅仅是减少了工作量，从汇编的角度不用重复构造compare()函数，从而减小了可执行文件的大小

  3. 函数模版的语法:

    • template 关键字用于声明开始进行泛型编程
    • typename 关键字用于声明泛指类型

  4. 需要注意的是：函数模板是不允许隐式类型转换的，调用时类型必须严格匹配

#include <iostream>
using namespace std;

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

int main()
{
    // 函数的调用点
    compare<int>(10, 20);
    compare<double>(10.1, 20.5);
    return 0;
}
  1. 模版函数的两种应用
    • 自动类型推导
    • 具体的类型显示调用
    • 详细的代码解释如下
#include <iostream>
using namespace std;


// template 告诉编译器即将开始泛型编程
template<typename T> // typename 告诉编译器后面代码中的T是一个泛指类型
void Swap(T &a, T &b)
{
    // 不带&，程序传递的是实参的副本，交换的是副本而非实参本身
    // 而当加了&，则传递的是实参的地址，程序将直接对实参进行交换
    T temp = a;
    a = b;
    b = temp;
}

int main()
{
    // 函数的调用点
    int a = 1;
    int b = 2;

    // 自动类型推导: a, b都是int -> T 也是int
    Swap(a, b); 
    cout << "a: " << a << " b: " << b << endl;

    // 显示类型调用: 用float替换参数类型T
    Swap<int>(a, b); 
    cout << "a: " << a << " b: " << b << endl;

    // 函数模板是不允许隐式类型转换的, 调用时类型必须严格匹配
    float c = 3.0;
    // Swap(a, c);  
    // Swap<float>(a, c); 配型错误也是错的
    return 0;
}

3. 通过符号表深入理解函数模版

  1. 无法自动推导函数的返回值
  2. 函数返回值在第一个参数中指定, 从左向右部分指定类型参数
#include <iostream>
using namespace std;

template <typename T1, typename T2, typename T3>
T1 add(T2 a, T3 b)
{
    T1 ret;
    ret = static_cast<T1>(a + b);
    return ret;
}

int main()
{
    int a = 10;
    float b = 0.5;

    // 报错的原因是无法自动推导函数的返回值
    // cout  << add(a, b) << endl;

    // 函数返回值在第一个参数中指定, 从做向右部分指定类型参数
    cout << add<int>(a, b) << endl; // 掉精度了

    cout << add<float, int, float>(a, b) << endl;
    cout << add<int, int, float>(a, b) << endl;
    return 0;
}

4. 函数模版的重载

  1. C++编译器优先考虑普通函数
  2. 如果函数模板可以产生一个更好的匹配，那么就选择函数模板
  3. 也可以通过空模板实参列表<>限定编译器只匹配函数模板
#include <iostream>
using namespace std;

// 一个泛指类型的函数模板
template <typename T1>
void fun(T1 a)
{
    cout << "T1 a template func" << endl;
}

// 两个泛指类型的函数模版
template <typename T1, typename T2>
void fun(T1 a, T2 b)
{
    cout << "T1 and T2 template func" << endl;
}

// 普通的void函数
void fun(int a, float b)
{
    cout << "int a, float b void func" << endl;
}

int main()
{
    int a = 10;
    float b = 10.5;
    fun(a); // 只有一个，跟第一个匹配上了

    // 普通函数能完美匹配上的时候，编译器优先选择普通函数
    fun(a, b);

    // 当函数模板有更好的调用的时候，用函数模板去调用
    fun(b, a);

    // 限定只使用函数模板, 就算完美匹配上也会优先调用模板函数
    fun<>(a, b); 

    return 0;
}

5. 函数模版总结

  1. 函数模板是泛型编程在C++中的应用方式之一
  2. 函数模版能根据实参类型对参数类型进行推导
  3. 函数模版支持显示的指定参数类型 (用实际类型去代替T)
// 显示的指定返回值为float, 参数a为int, b为float
add<float>(int a, float b);
  1. 函数模版是C++中重要的代码复用的方式
  2. 函数模版可以通过类型产生不同的函数，产生有不同的符号表
  3. 函数模版可以定义多个不同类型的参数 (typename a, typename b)
  4. 函数模版的返回值必须显示指定 (不确定返回类型的时候可以用static_cast<类型>强转来保证)
  5. 函数模版可以被重载
  6. 在任何一个模版中都必须使用template <typename 泛型>声明开始泛型编程

6. 类模版的定义

  1. 使用类模版构造对象必须指定数据类型 Operator op2;
  2. 编译器从类模版通过具体类型产生不同的类
  3. 编译器在声明的地方对类模版代码本身进行编译
  4. 编译器在使用的地方对参数替换后的代码进行了编译
  5. 只有被调用的类模板成员函数才会被编译器生成可执行代码
  6. 在类外定义累的成员函数，要加上template
#include <iostream>
using namespace std;

template<typename T>
class Operator
{
public:
    T add(T a, T b);

    T minus(T a, T b);
};

// 在类模版外定义成员函数，也要加上template 
template<typename T>
T Operator<T>::add(T a, T b)
{
    return a + b;
}

template<typename T>
T Operator<T>::minus(T a, T b)
{
    return a - b;
}

int main()
{
    Operator<int> op1;
    Operator<float> op2;
    cout << op1.add(3, 5) << endl;
    cout << op1.minus(3, 1.5) << endl; // op1.minus(3, 1)

    cout << op2.add(0.5, 0.2) << endl; 
    cout << op2.minus(3, 2) << endl; 

    return 0;
}

7. 类模版的完全特化

  1. 特化分成部分特化跟完全特化
  2. 表示可以存在多个相同的类名,但是模板类型都不一致(和函数重载的参数类似)
  3. 完全特化的意义
  • 如果您希望为特定类型提供特殊的实现，则可以使用类模板的完全特化版本。这样，您可以将代码的实现与代码的接口分离开来，并且在不同的情况下使用不同的实现。
  • 此外，类模板的完全特化版本还可以帮助您避免不必要的代码冗余，并且可以使代码更具可读性。因此，在某些情况下，使用类模板的完全特化版本可以是一种有效的代码组织方式。
  1. 看一个案例了解类模版的完全特化的意义
#include <iostream>

template <typename T>
class MyClass {
public:
 void print() {
   std::cout << "This is a generic version of MyClass." << std::endl;
 }
};

template <>
class MyClass<int> {
public:
 void print() {
   std::cout << "This is an integer-specialized version of MyClass." << std::endl;
 }
};

int main() {
 MyClass<double> myClass1;
 myClass1.print();  // Output: This is a generic version of MyClass.

 MyClass<int> myClass2;
 myClass2.print();  // Output: This is an integer-specialized version of MyClass.

 return 0;
}
  • 输出结果将不同，从而说明了如何使用类模板的完全特化版本来为特定类型提供特殊的实现。
  1. 类模版的特化匹配
// 类模版的特化

// 原始模版，也叫模版的声明
template<typename T1, typename T2>
class Operator
{
public:
    Operator()
    {
        cout << "Operator" << endl; 
    }

    void add(T1 a, T2 b)
    {
        cout << a + b << endl;
    }
};

// 完全特化的类模版不需要指定模版类型
template <>
class Operator<int, int>  // 指定类型参数，因为为2个参数，和正常模版参数个数一致
{
/*
原始的类模板 Operator 有两个泛型类型：T1 和 T2。因此，其创建的完全特化版本 Operator<int, int> 也必须有两个类型参数
*/
public:
    Operator()
    {
        cout << "Operator<int int>" << endl;
    }
    void add(int a, int b, int c)
    {
        cout << a + b << endl;
    }
};



int main()
{       
    // 匹配完全特化类模版
    Operator<int, int> op1;

    // 匹配正常模版
    Operator<int, float> op2;
    return 0;
}
  • 原始的类模板有两个泛型类型（例如 T1 和 T2），那么为其创建的完全特化版本也必须有两个类型参数，否则编译器将报错
  • 完全特化的类模版不能使用泛指类型 T1 和 T2
  1. 类模版的部分特化
  • 不管是部分特化的类模版还是完全特化的类模版，如果声明的类模版有两个参数，他们都要有两个参数
  • 编译时,会根据对象定义的类模板类型,首先去匹配完全特化,再来匹配部分特化,最后匹配正常的类模板
template<typename T1, typename T2> // 声明的类模版参数个数是两个
class Operator                     // 正常的类模版
{
public:
    Operator()
    {
        cout << "Operator" << endl;
    }
    void add(T1 a, T2 b)
    {
        cout << a + b << endl;
    }
};

template<typename T>     // 有指定模版类型及其参数，所以是部分特化的类模版
class Operator<T*, T*>   // 指定类型参数，必须为2个参数，和正常摩安参数个数一样
{
public:
Operator()
{
        cout << "Operator<T*, T*>" << endl;
}
void add(T* a, T* b)
{
        cout << *a + *b << endl;
}
};

template<typename T1, typename T2>     // 有指定模版类型及其参数，所以是部分特化的类模版
class Operator<T1*, T2*>   // 指定类型参数，必须为2个参数，和正常摩安参数个数一样
{
public:
Operator()
{
        cout << "Operator<T1*, T2*>" << endl;
}
void add(T1* a, T2* b)
{
        cout << *a + *b << endl;
}
};

int main()
{
Operator<int*, float*> op1; // 匹配部分特化模版
Operator<int, float> op2;   // 匹配原始模版
Operator<int *, int *> op3; // 匹配部分特化模版
}

8. 继承中类的模版使用

  1. 父类是一般类，子类是类的模版，没什么特别要注意的
class A
{
public:
    A(int temp): _temp(temp){}; 
    ~A(){}

private:
    int _temp;
};

template <typename T>
class B : public A
{
public:
    B(T t = 0): A(666)
    {
        this->t = t;
    }
    ~B(){}

private:
    T t;
};

int main()
{
    B<int> b;
    return 0;
}
  1. 子类是一般类，父类是模版类，继承的时候要写上类型，这就是模版的调用点
template<typename T>
class A
{
public:
    A(T t=0)
    {
        this->t = t;

    }

private:
    T t;
};

class B : public A<int>
{
public:
    B(int temp = 0):A<int>(666)
    {
        this->temp = temp;
    }

private:
    int temp;
};

int main()
{
    B b;
    return 0;
}
  1. 父类子类都是类模版
// 子类父类都是类模版
template <typename T1, typename T2>
class A   
{
    // 类的默认访问修饰词是private, 所以这里的x, y是私有属性
    // 如果向指定为公有的，需要修改饰词为public
    T1 x;
    T2 y;
};

template <typename T1, typename T2>
class B : public A<T2, T1>
{
    T1 x1;  
    T2 x2;  
};

template<typename T>
class C : public B<T, T>
{
    T x3;
};

int main()
{
    // B中的T1和A中的T1 泛指int, B中的T2,A中的T1 泛指float
    B<int, float> b;

    // 这样A，B，C中全部泛指类型都是int
    C<int> c;
    return 0;
}

9.总结:

  1. 请简要说明泛型编程的概念？
  • 泛型编程是一种编程方法，通过讲数据类型抽象化，使得代码可以在不同数据类型和参数之间通用，提高代码的可重复性和课扩展性。
  1. 请详细说明C++中模版函数和模版类的使用方法？
template <typename T>
void func(T arg1, T arg2, ...)
{
    // 函数实现
}

template <typename T>
class A
{
    // 类实现
};
  1. 函数模版可以做到自动类型推导，也支持具体类型的显示调用，但是无法自动推导函数的返回值。
  2. 函数模版的返回值在第一个参数指定，从左向右部分指定函数参数类型(即可以指定多个typename泛指类型)
  3. 函数模版支持重载，编译器优先考虑普通函数，如果函数模版有更好的选择才会选择函数模版，可以用空模版参数列表<>限定编译器只匹配函数模版
  4. 类模版和函数模版有部分特化和完全特化，通过指定类型来进行特化操作(定制化操作)
  5. 在C++中，可以使用默认类型来指定模版参数的默认值。例如，下面的代码中，模版参数默认为int类型
template <typename T = int>
class ClassName {
  // 类实现
};
  1. 在C++17中，可以使用模版参数的推导来自动推导模版参数的类型。例如，下面的代码中，编译器会自动推导出模版参数的类型
template <typename T>
void functionName(T arg) {
  // 函数实现
}

int main() {
  functionName(42); // 编译器自动推导出T为int类型
}
  1. 可以解释一下模版类的实现原理?
  • 模板类是一种将数据类型抽象化和参数化的编程技术，使得同一套类定义可以适用于不同的数据类型和参数。模板类定义了一种通用的类模板，实际上并不是一个真正的类，而是一个用于生成类的蓝图。在使用时，编译器会根据特定的模板参数实例化出对应的类。
  1. 使用模板类限制模版类型的属性和方法 concept(c++ 20的新特性)
template <typename T>
struct HasValue {
  template <typename U>
  static std::true_type test(decltype(&U::value));

  template <typename U>
  static std::false_type test(...);

  static constexpr bool value = decltype(test<T>(nullptr))::value;
};

template <typename T>
typename std::enable_if<HasValue<T>::value>::type
printValue(T arg) {
  std::cout << "Value: " << arg.value << std::endl;
}

struct MyStruct {
  int value = 42;
};

struct MyOtherStruct {
  float otherValue = 3.14f;
  int value = 43;
};

int main() {
  MyStruct s;
  MyOtherStruct os;

  printValue(s); // 输出：Value: 42

  // 下面这行代码会在编译时出现错误，因为MyOtherStruct类型不满足HasValue的限定条件
  printValue(os);
}
智障学AI
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《数学与泛型编程-高效编程的奥秘》个人阅读笔记
02-25
《数学与泛型编程-高效编程的奥秘》个人阅读笔记
C++提高编程 学习笔记
05-11
### C++ 提高编程学习笔记：泛型编程与 STL 技术详解 #### 一、泛型编程概述 泛型编程是一种编程范式，通过在程序设计中使用参数化的类型来编写代码，使得同一段代码可以处理多种不同的数据类型。这种编程方式极大...
【c++】泛型编程
sycamoreRD的博客
05-30 211
<class T>
C++--泛型编程
diyxuan的博客
07-08 1137
泛型编程的使用方法以及应用实例
C++ 的泛型编程
最新发布
weixin_62789590的博客
07-15 627
这个思想其实有两个层面，1、编写与数据类型无关的代码；2、使用模版元；
【C++】泛型编程
weixin_45423515的博客
08-31 5517
为了让函数或者类有更好的复用性，C++引入了摸板的技术。让不同的数据类型，能使用到相同的函数或者类中去，这种编程的思想也叫做泛型编程。
c++之泛型编程
雨于鱼的博客
05-07 198
一、定义    当你的算法不需要改变时，只是数据类型变化，一般情况下我们还是需要定义两个不同的函数体    但是引进了泛型编程之后数据类型和算法就分离了，这就是泛型编程的好处。二、使用    先举一个例子：    现在我们有两种参数需要来经过同一种算法来处理，假设两种数据类型为int和string，需要经过Swap    算法：template &lt;typename T&gt; void Sw...
C++之泛型编程
m0_60027772的博客
12-24 1905
建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用的数据类型函数声明或函数定义解释：声明创建模板表明其后面的符号为一种数据类型（该关键字也可以用class代替）通用的数据类型；名称可以替换，通常为大写字母。建立一个通用的类，类中的成员，数据类型可以不具体指定，用一个虚拟的类型来代表类解释：声明创建模板表明其后面带符号的是一种数据类型（也可以用class替换）
C++基础编程 学习笔记
05-13
- **C++** 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。 - **注释**： - **单行注释**：使用 `//` 开头，如：`// 这是一个单行注释` - **多行...
千锋C++笔记.zip
08-18
它支持面向对象编程、泛型编程和过程化编程，广泛应用于系统软件、应用软件、游戏开发、设备驱动程序等领域。 2. **基本语法**：C++的语法结构与C语言类似，包括变量声明、数据类型（如int、float、char等）、...
C++编程规范 Google 中文版 C++编程规范 自建笔记
05-29
对于泛型编程，理解并合理使用STL（Standard Template Library）容器、算法和迭代器。 7. **内存管理**：避免内存泄漏，正确使用`new`和`delete`，以及RAII（Resource Acquisition Is Initialization）原则。使用`...
C++：泛型编程
dddgggd的博客
07-14 316
泛型编程：模板的基本使用1.交换数字通用写法泛型编程2.利用模板实现通用数组排序3.函数模板与普通函数的区别及调用规则1.区别2.普通函数和函数模板的调用规则3.函数模板可以实现重载4.如果函数模板可以产生更好的匹配，那么优先调用函数模板4.模板机制5.模板的局限性及解决6.类模板的基本使用7.函数的调用时机8.类模板做函数的参数1.传入指定类型2.参数模板化3.整体类型化4.查看数据类型函数 1.交换数字 通用写法 void mySwap(int &a,int &b) { int
C++中的泛型编程
木子皿--啥都不会的菜鸟
02-13 470
文章目录1 C++中的泛型编程1.1 引入1.2 泛型编程 1 C++中的泛型编程 1.1 引入 发散性问题：C++中有几种交换变量的方法？ 交换变量的方法：定义宏代码块和定义函数。 示例代码如下： #include <iostream> #include <string> using namespace std; #define SWAP(t, a, b) \ ...
C++的泛型编程
Albert_weiku的博客
06-23 930
屏蔽掉数据和操作数据的细节，让算法更为同意通用，让编程者更多地关注算法的结构，而不是在算法中处理不同的数据类型
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值