一文搞懂C++泛型编程【函数模板、类模板】

简介: 一文搞懂C++泛型编程【函数模板、类模板】

前言


由于C++是静态语言,也就是说使用一个数据的时候必须先指定类型,这样的操作在编译后变量的类型是无法轻易改变的,就导致扩展性太差。或者一个函数需要很多次重载的时候,代码显得冗杂,由此产生了C++函数模板。



一、函数模板


1.函数模板介绍


① 函数模板的产生背景:


在编程时多多少少会因为函数参数不同写几个重载函数;
  函数模板的出现解决了仅仅因为参数类型不同而进行的函数重载;
解决方法:让类型作为参数传进函数或者自动类型推导,从而实现不同的功能;


② 函数模板的语法:


template<typename T>
返回类型 函数名(参数列表){函数体}
• 1
• 2


③ 函数模板的调用方式:


1.明显的调用  函数名<参数类型>(实参);-------------常用
2.自动函数推导  函数名(实参)


④ 函数模板的本质:类型参数化!


函数模板举例


重载了三次的max函数,使用函数模板一次就可以解决


#include<iostream>
using namespace std;
//--------------------------------函数模板前的比较大小
int  max(int a,char b) {
  return (a > b ? a : b);
}
float max(float a, float b) {
  return (a > b ? a : b);
}
long int max(long int a, long int b) {
  return (a > b ? a : b);
}
//--------------------------------用函数模板进行比较大小
template<typename T>
T max(T& a, T& b) {
  return (a > b ? a : b);
}
int main_001() {
  int a = 10;
  int b = 20;
  char a2 = 'a',b2='b';
  cout << max<int >(a, b) << endl;
  cout<<max(a, b)<<endl;
  cout << max(a2, b2) << endl;;
  return 0;
}


2.函数模板与重载函数的关系


① 普通函数的特性:


可以(隐式)进行参数类型自动转换;
• 1


② 函数模板的特性:


函数参数类型相同的话传进来的实参类型也必须相同(不允许自动转换);


调用规则:


  • 调用函数时优先考虑普通函数
  • 如果函数模板会有一个更好的匹配,那么选择模板函数;
  • 可以通过空模板实参列表的语法限定编译器只通过模板匹配;
  • 函数模板像普通函数一样也可以被重载
  • 使用规则如下:


#include<iostream>
using namespace std;
//此函数模板T1 T2代表两个不同类型的参数
//所以传进来的参数也要是不同类型(可以通过简单的操作改为传相同类型的参数)
template<typename T1,typename T2>
int  myadd(T1 a, T2 b) {
  return a + b;
}
int myadd(int a, int b) {
  return a + b;
}
int myadd(int a, char b) {
  return a + b;
}
int main() {
  int a = 10;
  int b = 20;
  char c = 'c';
  cout << myadd(a,b) << endl;//----------调用add(int,int)-----优先匹配的普通函数
  cout << myadd(a,c) << endl;//----------调用add(int ,char)
  cout << myadd(c,a) << endl;//----------调用add(t1,t2)-------没有该类型的普通函数就调用模板函数
  cout << myadd(c,c) << endl;//----------调用add(t1,t2)
  cout << myadd<>(a, b) << endl;//-------强制调用add(t1,t2)
  return 0;
}


3.函数模板实现机制


① 函数模板与模板函数:


1.函数模板:------------------------------仅仅是一个模板,并未被实例化(空壳子)
  template <typename T>
  返回类型 函数名 (参数列表){函数体}
2.模板函数:------------------------------通过类型的传入,将函数模板实例化
  函数模板的函数名<类型名>(参数列表);


② 函数模板机制剖析:


函数模板并不会直接产生能处理任意类型的参数的函数;
而是通过产生对应的模板函数实现对不同类型参数的处理;
函数模板进行两次编译
  1.函数模板声明的地方,对函数模板代码本身进行编译
    2.将类型插入后在调用的地方对插入参数后的代码进行编译


二、类模板


1.类模板基本语法


① 单个模板类:


基本语法:
  template<typename T>或template<class T>
  class 类名{private: T a;};
  注意事项:
  模板类是一个抽象类,定义对象时需要参数类型的传入
具体实现如下:


#include<iostream>
using namespace std;
template <class T>
class A {
public:
  void seta(T &a) {
    this->a = a;
  }
  void printA() {
    cout << this->a << endl;
  }
protected:
  T a;
};
int main() {
  int x = 888;
  A<int> a1;
  a1.seta(x);
  a1.printA();
  char xx = 'x';
  A<char> a2;
  a2.seta(xx);
  a2.printA();
  return 0;
}


② 模板类被具体类继承:


基本语法:
  定义: class 具体类名 :public 模板类名<参数类型>{};
  继承后的操作与普通类之间继承一样;
实现方法如下:


#include<iostream>
using namespace std;
template <class T>
class A {
public:
  void seta(T &a) {
    this->a = a;
  }
  void printA() {
    cout << this->a << endl;
  }
protected:
  T a;
};
class B :public A<int> {
private:
  int b;
public:
  void setb(int b) {
    this->b = b;
  }
  void printB() {
    cout << this->b << endl;
  }
};
int main() {
  int x = 888;
  B b1;
  b1.setb(999);
  b1.printB();
  b1.seta(x);
  b1.printA();
  return 0;
}


③ 模板类被模板类继承


类继承:
  基本语法:
  template<typename T>
  class 模板类名 :public 基类模板类名<T>{ };
具体实现方法:


#include<iostream>
using namespace std;
template <class T>
class A {
public:
  void seta(T &a) {
    this->a = a;
  }
  void printA() {
    cout << this->a << endl;
  }
protected:
  T a;
};
template <class T>
class C :public A<T> {//----------语法所在地
private:
  T c;
public:
  void setC(T &c) {
    this->c = c;
  }
  void printC() {
    cout << this->c << endl;
  }
};
class B :public A<int> {
private:
  int b;
public:
  void setb(int b) {
    this->b = b;
  }
  void printB() {
    cout << this->b << endl;
  }
};
int main() {
  int p = 99;
  C<int> c1;
  c1.setC(p);
  c1.printC();
  char pp = '6';
  C<char> c2;
  c2.setC(pp);
  c2.printC();
  return 0;
}


2.类模板内函数的整体布局【分文件使用类模板】


①所有函数均在类的内部


实现方法如下:


#include<iostream>
using namespace std;
template<typename T>
class complex1 {
  friend ostream& operator<< <T>(ostream &out, complex1 &obj);
private:
  T a;
  T b;
public:
  complex1(T a=0, T b=0) {
    this->a = a;
    this->b = b;
  }
  complex1 operator+(complex1 obj) {
    complex1 tem(a+obj.a,b+obj.b);
    return tem;
  }
  void printa() {
    cout << a << endl;
  }
  void printb() {
    cout << b << endl;
  }
};
template<typename T>
ostream& operator<<(ostream &out, complex1<T> &obj) {
    out << obj.a << "+" << obj.b << "i" << endl;
    return out;
  }
int main_11() {
  complex1<int> a(1, 2), b(3, 4);
  complex1<int>c = a + b;
  cout << c << a << b;
  a.printa();
  a.printb();
  return 0;
}


②所有函数均在类的外部,但在同一文件


成员函数实现语法:
  原型: 类名 函数名 (参数列表);
  修改后的形式:  
  template <typename T>
  类名<T> 函数名 (参数列表)------参数列表该加T的就加T
流运算符 友元函数实现语法:
  原型(声明): friend 返回类型 函数名 (参数列表);
  修改后的形式:
  (声明) :friend 返回类型 函数名 <T> (参数列表) ;
  template<typename T>
  (函数实现): 返回类型 函数名 (参数列表){};------类的对象做参数时修改为 类名<T>;


具体实现如下


#include<iostream>
using namespace std;
template<typename T>
class complex2 {
  friend ostream& operator<< <T>(ostream& out, complex2& obj);
private:
  T a;
  T b;
public:
  complex2(T a = 0, T b = 0);
  complex2 operator+(complex2 obj);
  void printa();
  void printb();
};
template<typename T>
complex2<T>::complex2<T>(T a , T b ) {
  this->a = a;
  this->b = b;
}
template<typename T>
complex2<T> complex2<T>::operator+(complex2 obj) {
  complex2 tem(a + obj.a, b + obj.b);
  return tem;
}
template<typename T>
void complex2<T>::printa() {
  cout << a << endl;
}
template<typename T>
void complex2<T>::printb() {
  cout << b << endl;
}
template<typename T>
ostream& operator<<(ostream& out, complex2<T>& obj) {
  out << obj.a << "+" << obj.b << "i" << endl;
  return out;
}
int main_dd() {
  complex2<int> a(1, 2), b(3, 4);
  complex2<int>c = a + b;
  cout << c << a << b;
  a.printa();
  a.printb();
  return 0;
}


③ 所有函数均在类的外部,但在不同文件


将类分文件写后,将类函数实现的部分包含进主函数所在的文件
实现方法:
#include"xxxx.cpp"
示例:


头文件


#pragma once
#include<iostream>
using namespace std;
template<typename T>
class complex {
  friend ostream& operator<< <T>(ostream& out, complex& obj);
private:
  T a;
  T b;
public:
  complex(T a = 0, T b = 0);
  complex operator+(complex obj);
  void printa();
  void printb();
};


函数实现


#include<iostream>
using namespace std;
#include"复数类3.h"
template<typename T>
complex<T>::complex<T>(T a, T b) {
  this->a = a;
  this->b = b;
}
template<typename T>
complex<T> complex<T>::operator+(complex obj) {
  complex tem(a + obj.a, b + obj.b);
  return tem;
}
template<typename T>
void complex<T>::printa() {
  cout << a << endl;
}
template<typename T>
void complex<T>::printb() {
  cout << b << endl;
}
template<typename T>
ostream& operator<<(ostream& out, complex<T>& obj) {
  out << obj.a << "+" << obj.b << "i" << endl;
  return out;
}


主函数


#include<iostream>
using namespace std;
#include"复数类3h.cpp"//重点
int main() {
  complex<int> a(1, 2), b(3, 4);
  complex<int>c = a + b;
  cout << c << a << b;
  a.printa();
  a.printb();
  return 0;
}


3.类模板的static与模板类的static


类模板定义了变量,函数实现的步骤,但没有数据类型的插入,所以类模板仅仅是模板;
类模板的实现机制是程序员给出数据类型,编译器对具体的类进行实现,产生不同类型的类;
所以,类模板中的静态成员变量是某个类型的具体类独有的成员变量;只是被该类型对象所公有
区别如下:
  模板类中的static变量可以被该模板类的对象公用
  类模板的static经过类不同方式的实例化,会产生不同的static变量,
  且该变量只供初始化他的类使用


4.数组实现万能容器


testarray类是一个类模板,里面有一个指针类型,所以通过程序员主动实现模板类传参
可以存储不同类型的数据,也就是说testarray理论可以存储任意类型的数据。


#include<iostream>
using namespace std;
class teacher {
private:
  char *name;
  char *sex;
  int age;
public:
  teacher() {
    name = NULL;
    sex = NULL;
    age = 0;
  }
  teacher(teacher& obj) {
    if (name != NULL) {
      delete [] name;
      delete[] sex;
    }
    age = obj.age;
    name = new char [sizeof(obj.name)];
    sex = new char[sizeof(obj.sex)];
    strcpy_s(name, sizeof(obj.name), obj.name);
    strcpy_s(sex, sizeof(obj.sex), sex);
  }
  void setname(char *name) {
    this->name = new char[strlen(name)+1];
    strcpy_s(this->name, strlen(name)+1, name);
  }
  void setage(int age) {
    this->age = age;
  }
  void setsex(char* sex) {
    this->sex = new char[strlen(sex)+1];
    strcpy_s(this->sex, strlen(sex)+1, sex);
  }
  friend ostream& operator<<(ostream& out, teacher& obj);
};
ostream& operator<<(ostream& out, teacher& obj) {
  cout << "姓名" << "\t" << "性别" << "\t" << "年龄" << endl;
  cout << obj.name << "\t" << obj.sex << "\t" << obj.age << endl;
  return out;
}
ostream& operator<<(ostream& out, teacher& obj);
template <typename T>
class testarray {
  friend ostream& operator<< <T>(ostream& out, testarray& obj);
private:
  int len;
  T* myarray;
public:
  testarray() {
    len = 0;
    myarray = NULL;
  }
  testarray(int len) {
    this->len=len;
    myarray = new T[len];
  }
  testarray(testarray & obj) {
    len = obj.len;
    myarray = new testarray;
    strcmp_s(myarray, len, obj.myarray);
  }
  T& operator[](int xx) {
    return myarray[xx];
  } 
};
template<typename T>
ostream& operator<<(ostream& out,testarray<T>& obj) {
  for (int i = 0;i < obj.len;i++) {
    cout << obj[i] <<" ";
  }
  cout << endl;
  return out;
}
int main() {
  testarray<int> aint(10);
  testarray<char> bchar(10);
  testarray<teacher> tea(3);
  teacher t1, t2, t3;
  char name1[]="小李",name2[]="小朱",name3[]="小黄";
  char sex1[] = "男", sex2[] = "女";
  t1.setname(name1);
  t1.setsex(sex2);
  t1.setage(40);
  t2.setname(name2);
  t2.setsex(sex1);
  t2.setage(20);
  t3.setname(name3);
  t3.setsex(sex1);
  t3.setage(28);
  tea[0] = t1;
  tea[1] = t2;
  tea[2] = t3;
  for (int i = 0;i < 10;i++) {
    aint[i] = i;
  }
  for (int i = 0;i < 10;i++) {
    bchar[i] = i + 97;
  }
  cout << aint;
  cout << bchar;
  cout << tea;
  return 0;
}


效果图


e3826bfd6ba545ff892c85fbe885068a.png


实现思路
  类模板实现对不同数据类型的变量进行处理后
  该变量要有针对该操作  自己处理自身的方法
换句话说就是
  类模板仅仅对某种类型的处理发出指令
  而细枝末节的处理方式(算法),要该类型自己的方法去实现


总结


类模板与函数模板一样也会经过两次编译,在此文中重点区分一下类模板与模板类,函数模板与模板函数的概念,泛型编程是C++开发的一大精髓,灵活地运用泛型编程对我们以后学习其他的编程语言有很大的帮助,后期还会更新一些C++小demo,包括C++三大特性的运用与泛型机制的运用,还会更新C++图像库easyX。欢迎大家点赞收藏。

相关文章
|
1月前
|
C++ 芯片
【C++面向对象——类与对象】Computer类(头歌实践教学平台习题)【合集】
声明一个简单的Computer类,含有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等,以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制,用于保护类的数据不被外部随意修改。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。成员可以在派生类(继承该类的子类)中访问。成员,在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务,你需要掌握。
68 19
|
1月前
|
存储 编译器 数据安全/隐私保护
【C++面向对象——类与对象】CPU类(头歌实践教学平台习题)【合集】
声明一个CPU类,包含等级(rank)、频率(frequency)、电压(voltage)等属性,以及两个公有成员函数run、stop。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中,类是创建对象的蓝图。类的声明定义了类的成员,包括数据成员(变量)和成员函数(方法)。一个简单的类声明示例如下: classMyClass{ public: int
50 13
|
1月前
|
编译器 数据安全/隐私保护 C++
【C++面向对象——继承与派生】派生类的应用(头歌实践教学平台习题)【合集】
本实验旨在学习类的继承关系、不同继承方式下的访问控制及利用虚基类解决二义性问题。主要内容包括: 1. **类的继承关系基础概念**:介绍继承的定义及声明派生类的语法。 2. **不同继承方式下对基类成员的访问控制**:详细说明`public`、`private`和`protected`继承方式对基类成员的访问权限影响。 3. **利用虚基类解决二义性问题**:解释多继承中可能出现的二义性及其解决方案——虚基类。 实验任务要求从`people`类派生出`student`、`teacher`、`graduate`和`TA`类,添加特定属性并测试这些类的功能。最终通过创建教师和助教实例,验证代码
50 5
|
1月前
|
存储 算法 搜索推荐
【C++面向对象——群体类和群体数据的组织】实现含排序功能的数组类(头歌实践教学平台习题)【合集】
1. **相关排序和查找算法的原理**:介绍直接插入排序、直接选择排序、冒泡排序和顺序查找的基本原理及其实现代码。 2. **C++ 类与成员函数的定义**:讲解如何定义`Array`类,包括类的声明和实现,以及成员函数的定义与调用。 3. **数组作为类的成员变量的处理**:探讨内存管理和正确访问数组元素的方法,确保在类中正确使用动态分配的数组。 4. **函数参数传递与返回值处理**:解释排序和查找函数的参数传递方式及返回值处理,确保函数功能正确实现。 通过掌握这些知识,可以顺利地将排序和查找算法封装到`Array`类中,并进行测试验证。编程要求是在右侧编辑器补充代码以实现三种排序算法
40 5
|
1月前
|
Serverless 编译器 C++
【C++面向对象——类的多态性与虚函数】计算图像面积(头歌实践教学平台习题)【合集】
本任务要求设计一个矩形类、圆形类和图形基类,计算并输出相应图形面积。相关知识点包括纯虚函数和抽象类的使用。 **目录:** - 任务描述 - 相关知识 - 纯虚函数 - 特点 - 使用场景 - 作用 - 注意事项 - 相关概念对比 - 抽象类的使用 - 定义与概念 - 使用场景 - 编程要求 - 测试说明 - 通关代码 - 测试结果 **任务概述:** 1. **图形基类(Shape)**:包含纯虚函数 `void PrintArea()`。 2. **矩形类(Rectangle)**:继承 Shape 类,重写 `Print
48 4
|
1月前
|
设计模式 IDE 编译器
【C++面向对象——类的多态性与虚函数】编写教学游戏:认识动物(头歌实践教学平台习题)【合集】
本项目旨在通过C++编程实现一个教学游戏,帮助小朋友认识动物。程序设计了一个动物园场景,包含Dog、Bird和Frog三种动物。每个动物都有move和shout行为,用于展示其特征。游戏随机挑选10个动物,前5个供学习,后5个用于测试。使用虚函数和多态实现不同动物的行为,确保代码灵活扩展。此外,通过typeid获取对象类型,并利用strstr辅助判断类型。相关头文件如&lt;string&gt;、&lt;cstdlib&gt;等确保程序正常运行。最终,根据小朋友的回答计算得分,提供互动学习体验。 - **任务描述**:编写教学游戏,随机挑选10个动物进行展示与测试。 - **类设计**:基类
32 3
|
3月前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色,它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作,帮助读者更好地理解和掌握`string`类的应用。
89 2
|
3月前
|
存储 编译器 C++
【c++】类和对象(下)(取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象)
本文介绍了C++中类和对象的高级特性,包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项,帮助读者深入了解C++面向对象编程的核心机制。
156 5
|
3月前
|
存储 编译器 C++
【c++】类和对象(中)(构造函数、析构函数、拷贝构造、赋值重载)
本文深入探讨了C++类的默认成员函数,包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化,析构函数用于对象销毁时的资源清理,拷贝构造函数用于对象的拷贝,赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项,并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
169 4
|
3月前
|
存储 编译器 Linux
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
247 4