C++泛型编程函(数模板+类模板)

目录

• 一、函数模板
• 1.函数模板介绍
• 2.函数模板与重载函数的关系
• 3.函数模板实现机制
• 二、类模板
• 1.类模板基本语法
• 2.类模板内函数的整体布局【分文件使用类模板】
• 3.类模板的static与模板类的static
• 4.数组实现万能容器

前言:

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

一、函数模板

1.函数模板介绍

① 函数模板的产生背景:

• 在编程时多多少少会因为函数参数不同写几个重载函数；
• 函数模板的出现解决了仅仅因为参数类型不同而进行的函数重载;

解决方法:让类型作为参数传进函数或者自动类型推导,从而实现不同的功能;

② 函数模板的语法：

tmplate

返回类型 函数名(参数列表){函数体}

③ 函数模板的调用方式:

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

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

函数模板举例

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

#include
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
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(a, b) << endl;
    cout< 
 

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

① 普通函数的特性:

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

② 函数模板的特性:

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

调用规则:

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

使用规则如下：

clude
using namespace std;
//此函数模板T1 T2代表两个不同类型的参数
//所以传进来的参数也要是不同类型（可以通过简单的操作改为传相同类型的参数）
template
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

返回类型 函数名 (参数列表){函数体}

2.模板函数:------------------------------通过类型的传入,将函数模板实例化

 函数模板的函数名<类型名>(参数列表);

② 函数模板机制剖析：

• 函数模板并不会直接产生能处理任意类型的参数的函数;
• 而是通过产生对应的模板函数实现对不同类型参数的处理；

函数模板进行两次编译：
    1.函数模板声明的地方,对函数模板代码本身进行编译
    2.将类型插入后在调用的地方对插入参数后的代码进行编译

二、类模板

1.类模板基本语法

① 单个模板类:

基本语法:

  template或template
  class 类名{private: T a;};

注意事项:

模板类是一个抽象类,定义对象时需要参数类型的传入

具体实现如下:

#include
using namespace std;
template 
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 a1;
    a1.seta(x);
    a1.printA();
    char xx = 'x';
    A a2;
    a2.seta(xx);
    a2.printA();
    return 0;
}

② 模板类被具体类继承:

基本语法:

  定义: class 具体类名 :public 模板类名<参数类型>{};

•  继承后的操作与普通类之间继承一样;

实现方法如下:

#include
using namespace std;
template 
class A {
public:
    void seta(T &a) {
        this->a = a;
    }
    void printA() {
        cout << this->a << endl;
    }
protected:
    T a;
};
class B :public A {
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
  class 模板类名 :public 基类模板类名{ };

具体实现方法:

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

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

①所有函数均在类的内部

实现方法如下:

#include
using namespace std;
template
class complex1 {
    friend ostream& operator<< (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
ostream& operator<<(ostream &out, complex1 &obj) {
        out << obj.a << "+" << obj.b << "i" << endl;
        return out;
    }
int main_11() {
    complex1 a(1, 2), b(3, 4);
    complex1c = a + b;
    cout << c << a << b;
    a.printa();
    a.printb();
    return 0;
}

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

员函数实现语法:

 原型: 类名 函数名 （参数列表）;

修改后的形式:  
    template
    类名 函数名 （参数列表）------参数列表该加T的就加T

流运算符 友元函数实现语法:
    原型(声明): friend 返回类型 函数名 （参数列表）；

 修改后的形式:
    (声明) ：friend 返回类型 函数名 (参数列表) ；
    template
    (函数实现): 返回类型 函数名 （参数列表）{};------类的对象做参数时修改为 类名;

具体实现如下：

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

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

将类分文件写后,将类函数实现的部分包含进主函数所在的文件

实现方法:

include"xxxx.cpp"

示例:

头文件：

#pragma once
#include
using namespace std;
template
class complex {
    friend ostream& operator<< (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
using namespace std;
#include"复数类3.h"
template
complex::complex(T a, T b) {
    this->a = a;
    this->b = b;
}
template
complex complex::operator+(complex obj) {
    complex tem(a + obj.a, b + obj.b);
    return tem;
}
template
void complex::printa() {
    cout << a << endl;
}
template
void complex::printb() {
    cout << b << endl;
}
template
ostream& operator<<(ostream& out, complex& obj) {
    out << obj.a << "+" << obj.b << "i" << endl;
    return out;
}

主函数：

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

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

类模板定义了变量,函数实现的步骤,但没有数据类型的插入,所以类模板仅仅是模板;
类模板的实现机制是程序员给出数据类型,编译器对具体的类进行实现,产生不同类型的类;
所以,类模板中的静态成员变量是某个类型的具体类独有的成员变量;只是被该类型对象所公有

区别如下：

•     模板类中的static变量可以被该模板类的对象公用    
•     类模板的static经过类不同方式的实例化,会产生不同的static变量，
•     且该变量只供初始化他的类使用

4.数组实现万能容器

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

#include
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 
class testarray {
    friend ostream& operator<< (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
ostream& operator<<(ostream& out,testarray& obj) {
    for (int i = 0;i < obj.len;i++) {
        cout << obj[i] <<" ";
    }
    cout << endl;
    return out;
}
int main() {
    testarray aint(10);
    testarray bchar(10);
    testarray 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;
}

效果图：

实现思路：

•     类模板实现对不同数据类型的变量进行处理后
•     该变量要有针对该操作  自己处理自身的方法

换句话说就是：

•     类模板仅仅对某种类型的处理发出指令
•     而细枝末节的处理方式(算法),要该类型自己的方法去实现

总结：

类模板与函数模板一样也会经过两次编译,在此文中重点区分一下类模板与模板类,函数模板与模板函数的概念,泛型编程是C++开发的一大精髓,灵活地运用泛型编程对我们以后学习其他的编程语言有很大的帮助

到此这篇关于C++泛型编程函(数模板+类模板)的文章就介绍到这了,更多相关C++泛型编程函内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！