C++泛型编程

一、什么是泛型编程

泛型编程 是一种编程范式,它通过编写可以处理多种数据类型的代码来实现代码的灵活复用。泛型编程主要通过模板来实现。

比如我们日常使用的容器类型vector就应用了模板来实现其通用性,我们在使用时可以通过传入型别创建对应的动态数组,如传入int定义vector<int> 整形数组,也可以传入char创建 vector<char> 字符数组等。

二、模板简介

1、简介

泛型编程主要使用模板来实现。模板就是允许你编写与类型无关的代码,即对所有传入的数据类型编写通用的实现代码。

比如,我想返回传入数据的占内存大小。对这个问题的解决,可以不依赖数据类型,我们都可以通过相同的操作返回结果。

template <typename T>
size_t getSize(const T& data) {
    return sizeof(data);
}

2、模板分类

模板主要分为函数模板和类模板。

函数模板是使用泛型参数的函数。例如如下函数

template<typename T>
T add_func(T a, T b){
    return a + b;
}

类模板即使用泛型参数的类。例如如下类,成员参数或成员函数中可以动态指定参数类型

template<typename T>
class MClass{
public:
    MClass(){}
    MClass(T t):__data(t){}
    T getData(){
        return __data;
    }

private:
        T __data;
};

3、模板实例化

模板的声明知识给出一个函数或类提供一个语法框架,其实并没有完成成为一个函数或类。当你定义一个模板时,编译器并不立即生成代码。

当你在代码中使用模板时,编译器会根据传入的类型生成对应的代码。这被称为模板实例化。每当使用新的类型实例化一个模板时,编译器会生成一份新的代码副本。

编译阶段,编译器在模板实例化时会进行类型检查和其他错误检查,确保传入的类型符合模板的要求。如果有错误,编译器会报告这些错误。

运行阶段,模板已经被实例化并编译成代码,则运行时行为与普通函数相同。模板本身的特性不会影响运行时的性能,生成的代码是静态的。

如上述的函数模板,我们就可以通过传入参数类型int、char、double等构建出add_func<int>、add_func<char>、add_func<double>等不同的函数实例。

模板实例化有2种方式:

显式实例化:直接在代码中明确指定传入型别,如下方式的调用就是显式实例化

add_func<double>(5.09, 10.26);

隐式实例化:让编译器通过传入的参数进行型别推导完成的实例化。例如下面的调用,编译器会根据传入的数据,推导为add_func<int>的函数

add_func(2, 8);

 关于隐式实例化,一定要注意要能让编译器推导出型别。如下代码,只有一个模板参数的情况下,却传入了两种类型的值。类似这种情况编译器无法完成型别推导,就会报错。这时,可以

1)将数据类型强转为相同类型; 2)显式实例化模板 即可编译通过。

int main(){
    add_func(5.09, 28); //ERROR:无法推导出T的型别
    add_func(5.09, static_cast<double>(28)); //OK 将28强转为double后,只存在一种数据类型了,编译器可以推导出T=double
    add_func<int>(5.09, 28); //OK 显式得指定T为int,不用编译器推导,在调用时5.09会被强转为int型使用(会丢失精度)
}

三、函数模板

以函数形式定义的模板,它可以定义一族函数。函数模板可以指定一个或者多个类型参数,这些类型参数在具体调用时被具体数据类型取代。

函数模板的定义

函数模板的定义如下代码:

注意:每个函数模板都要在其之前使用template<>声明,不可复用。

// 指定一个参数类型的函数模板
template<typename T>
void func(T t){}

// 指定多个参数类型的函数模板
template<typename T1, typename T2>
T2 func(T1 t){  return T2();}

//指定可变参数函数模板
template<typename ...Args>
void func(Args ...args){}

模板定义的语法不用多说,但是模板参数有很多知识点需要掌握。

函数模板参数

从上面看,我们知道模板参数可以是一个,可以是多个,也可以是可变参数。其中可变参数需要详细介绍,所以博主又写了一篇文章,大家可以参考

可变参数函数、可变参数模板和折叠表达式_可变参数模板函数-优快云博客

下面介绍下关于模板参数的其他知识点

默认模板参数

模板的参数列表也可以设置默认传入类型。和函数参数默认值一样,默认类型必须在右侧。如下代码所示

template <typename T1, typename T2 = int>
void printData(T1 a, T2 b = 0)
{
    cout << a << " " << b << endl;
}

int main(){
    printData<string>("print data:", 97); //默认是int类型,会打印97
    printData<string, char>("print data:", 97); //指定是char类型,会打印'a'

    return 0;
}

输出:

非类型模板参数

 除了类型模板参数,在模板中还可以使用非类型模板参数。如下代码所示,参数N是一个size_t常量参数,而不是个类型参数。

并且非类型参数也可以有默认值。

template<typename T, size_t N = 10>
T cal_func(T a, T b){
    return (a + b) * N;
}

int main(){
    cout << cal_func(2,3) <<endl;
    cout << cal_func<int, 20>(2,3) <<endl;
}

输出

并不是所有参数类型都可以作为模板的非类型参数。非类型模板参数仅支持整形、枚举类型、字符常量几种。具体我放在类模板单元介绍,因为它们主要使用在类模板中,函数模板虽然在语法上也支持,但是用的不常见。

函数模板的重载

函数模板也可以像普通函数一样被重载,也可以重载普通函数,编译器可以通过推导来决定调用哪个函数

// 1、普通函数
void func(int a){
    cout << "func 1 called!!! value=" << a << endl;
}
// 2、具有一个模板参数的函数模板
template<typename T>
void func(T a){
    cout << "func 2 called!!! value=" << a << endl;
}
// 3、具有2个模板参数的函数模板
template<typename T>
void func(T a, T b){
    cout << "func 3 called!!! value=" << a << endl;
}
// 4、具有可变参数的函数模板
template<typename...Args>
void func(Args...args){
    cout << "func 4 called!!!" << endl;
}


int main(){
    func(1);
    func<int>(2);
    func(3, 4);
    func(5.6);
    func(7, 8.9);
}

输出

如上述代码:函数func有3个重载版本,其中第一个是普通函数。

从调用结果看:

1)当直接传入一个int型参数时,调用的是普通函数func 1;

2)当显式调用一个模板函数时,即func<int>时,无论参数是什么,都会调用函数模板;

3)当传入一个非int型参数时,会调用具有一个模板参数的func 2;

4)当传入两个相同类型参数时,会隐式调用具有两个相同类型参数的模板函数func 3;

5)当传入两个不同类型参数时,编译器调用了可变参数的模板函数 func 4.

从上面结果可以推断出,编译器会优先调用更明确的函数,而不是选择推导;如果没有更明确的选择,必须要使用模板,编译器会优先选择推导更少的模板参数。即如果同时存在普通函数和模板函数可以调用时,编译器会优先调用普通函数;如果同时存在多个模板函数可以选择,编译器会选择调用具有更少“推导工作量”的模板函数。

函数模板的特化

模板的特化是指为特定类型或特定参数数量提供自定义实现。这允许开发者为某些类型提供更高效或更适合的实现,而不必改变模板的整体设计。

有两种主要类型的特化:

  1. 全特化:为特定类型提供完全不同的实现。
  2. 偏特化:为某些特定类型组合提供不同的实现,但保留模板的一部分灵活性。

但是函数模板只允许全特化

如下,我们实现一个判断是否相等的函数模板,但是因为浮点数不能使用“==”判断是否相等,所以进行了全特化

template<typename T>
bool Equal(T a, T b){
    return a == b;
}
// 全特化
template<>
bool Equal<double>(double a, double b){
    return abs(a-b) < 0.0001;
}

int main(){
    cout << Equal(1, 2) << endl;
    cout << Equal(1.1, 1.1000001) << endl;
}

输出:

关于特化的剩余知识在类模板介绍。

四、类模板

类模板允许创建类的模板定义,类中的成员变量和成员函数都可以使用传入的数据类型确定。

类模板定义

类模板的定义形式和函数模板没有太大区别。只不过类模板不仅可以将成员函数的形参、返回值泛化,也可以将成员变量进行泛化。我把上面的类模板定义代码拷贝下来,大家可以再复习下

template<typename T>
class MClass{
public:
    MClass(){}
    MClass(T t):__data(t){}
    T getData(){
        return __data;
    }

private:
        T __data;
};

在类模板的定义中,还有些函数模板涉及不到的注意事项:

1)如果在类模板中涉及到对类对象本身的使用,需要完整写出类模板名称,类似MClass<T>而不是只简单些MClass;

2)如果需要再类声明之外进行初始化(例如类静态成员变量)的成员,以及进行定义的成员(例如类成员函数),都需要完整地声明出模板参数;

如下代码,是相对比较复杂的类模板定义,简单实现了一个数组的功能

template <typename T, unsigned N>
class Array {
private:
    T data[N]; // 使用 N 定义数组大小
public:
    Array<T, N>& operator =(const Array<T, N>& other){}
    void setData(int i, T dat);
    T getData(int i){
        return data[i];
    }
};

template <typename T, unsigned N>
void Array<T, N>::setData(int i, T dat){
    if (i >=0 && i < N){
        data[i] = dat;
    }
}

int main(){
    Array<int, 10> arr;
    arr.setData(5, 999);
    cout << arr.getData(5) << endl;
}

输出

类模板参数

类模板的参数和函数模板类似,可以是一个,可以是多个,也可以是可变参数,也可以传入默认参数类型,这里就不再赘述。

下面重点介绍下在函数模板中没有说完的非类型模板参数的使用。

非类型模板参数

非类型模板参数支持整形、枚举类型、字符常量下面逐个介绍。

1、整形变量

类型:如size_t、int、unsigned int等

用途:

  • 经常用于定义数组大小、循环次数、容量等
  • 可以为函数或类提供编译时确认的常量

例如,

template <typename T, std::size_t N>
class Array {
public:
    T data[N]; // 使用 N 定义数组大小
};

int main(){
    Array<int, 10> arr;
    cout << sizeof(arr.data)/sizeof(int) << endl;
}

输出

2、枚举类型

类型:enum

用途

  • 提供一种方式来选择特定的行为或配置
  • 可以用作模板参数来控制模板的行为
enum class Color { Red, Green, Blue };

template <Color C>
class ColorBox {
public:
    void display() {
        if constexpr (C == Color::Red) {
            std::cout << "Red Box\n";
        } else if constexpr (C == Color::Green) {
            std::cout << "Green Box\n";
        } else {
            std::cout << "Blue Box\n";
        }
    }
};

int main(){
    ColorBox<Color::Green> cbox;
    cbox.display();
}

输出

3、字符常量

类型:char

用途:

  • 可以用于定义固定的字符串或字符常量
  • 常用于模板元编程中,例如处理字符串或字符集

使用举例

template <char C>
class CharPrinter {
public:
    void print() {
        std::cout << C << std::endl;
    }
};

int main(){
    CharPrinter<'A'> cp;
    cp.print();
}

输出

非类型模板参数的作用
  • 灵活性:非类型模板参数允许你编写更灵活和高效的代码。
  • 性能:由于在编译时已确定值,能提升性能。
  • 错误检查:使用非类型参数时,可以在编译阶段捕获错误,减少运行时错误。

类模板特化

类模板可以全特化也可以偏特化(也叫部分特化)。特化后的具体实现可以和泛式的实现不一样

类模板全特化

类模板全特化的格式和函数模板全特化基本相同

// 类模板
template<typename T, typename U>
class MClass{}

// 全特化版本
template<>
class MClass<int, string>{};

上面的全特化版本用于特殊处理类型参数是<int, string>的问题。

类模板偏特化

如下类模板声明

// 类模板
template<typename T, typename U>
class MClass{};

// 部分特化-特化第二个类型参数为string
template<typename T>
class MClass<T, string>{};

// 部分特化-特化第一个类型参数为int
template<typename T>
class MClass<int, T>{};

下面,我写出完整地类模板、全特化和偏特化的几个类声明。及它们的使用。

示例代码

// 类模板
template<typename T, typename U>
class MClass{
public:
    MClass(){
        cout << "MClass T U called" << endl;
    }
};
// 全特化版本
template<>
class MClass<int, string>{
public:
    MClass(){
        cout << "MClass int str called" << endl;
    }
};
// 部分特化-特化第二个类型参数为string
template<typename T>
class MClass<T, string>{
public:
    MClass(){
        cout << "MClass T str called" << endl;
    }
};
// 部分特化-特化第一个类型参数为int
template<typename T>
class MClass<int, T>{
public:
    MClass(){
        cout << "MClass int T called" << endl;
    }
};

int main(){
    MClass<int, string> c1;
    MClass<int, double> c2;
    MClass<double, string> c3;
    MClass<char, int> c4;
    return 0;
}

输出

从上面的代码中,我们可以看到,有些调用可以匹配多个类模板。比如如下这句调用,它可以使用MClass<int, string>的全特化版本,也可以使用MClass<int, T>或MClass<T, string>的偏特化版本,更可以使用MClass<T, U>的无特化一般版本。但为什么只调用了MClass<int, string>的全特化版本呢?

MClass<int, string> c1;

这是因为,编译器在查找类模板时,会优先匹配全特化版本,其次是偏特化版本,最后才是一般模板。

所以,上面的输出结果那般。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值