c++函数模板和类模板

最新推荐文章于 2024-07-12 16:34:36 发布
最新推荐文章于 2024-07-12 16:34:36 发布
阅读量918 收藏 1
点赞数
分类专栏： C/C++ 文章标签： 函数 c语言 class c++ 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ydxlt/article/details/51018022
版权

一、函数模板

  • 定义形式：

    template <typename type1,typename type2,...> return-type func-name(parameter list)
{
   // 函数的主体
}

    说明：

    1. type1和type2…是占位符，用来泛指任意类型，如T，K…。
    2. template和typename是关键字；

  • 函数模板的调用：

    1. 显示类型调用
    2. 自动类型推导

    例子：

    #include <iostream>

using namespace std;

// 开始泛型编程
template <typename T>

void myswap(T &a,T &b){
    T c = 0;
    c = a;
    a = b;
    b = c;
}

void testInt(){
    int a = 1;
    int b = 2;
    // 显示调用函数模板
    myswap<int>(a,b);
    cout << "a = " <<a<< " b = "<<b<<endl;

    // 自动类型退导
    myswap(a,b);
    cout << "a = " <<a<< " b = "<<b<<endl;
}

void testChar(){
    char a = 'a';
    char b = 'b';

    // 显示调用函数模板
    myswap<char>(a,b);
    cout << "a = " <<a<< " b = "<<b<<endl;

    // 自动类型退导
    myswap(a,b);
    cout << "a = " <<a<< " b = "<<b<<endl;
}

int main01(){
    testInt();
    testChar();
}

  • 函数模板强化：对字符数组或int数组进行排序

    // 对字符数组 int数组进行排序
#include <iostream>

using namespace std;

template <typename T,typename K>
void mySort(T *arr,K size){
    T tmp;
    for(int i=0;i<size;i++){
        for(int j = i+1;j<size;j++){
            if(arr[i]>arr[j]){
                tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

template <typename T,typename K>
void printArr(T *arr,K size){
    for(int i=0;i<size;i++){
        cout << arr[i] << "  ";
    }
    cout << endl;
}

void testIntArr(){
    int arr[] = {12,34,5,7,91,23,45,11,8};
    int size = sizeof(arr)/sizeof(*arr);
    cout << "排序前..." <<endl;
    printArr(arr,size);
    mySort<int,int>(arr,size);
    cout << "排序后..." <<endl;
    printArr(arr,size);
}

void testCharArr(){
    char arr[] = {'b','a','e','c','d','g','h'};
    int size = sizeof(arr)/sizeof(*arr);
    cout << "排序前..." <<endl;
    printArr(arr,size);
    mySort<char,int>(arr,size);
    cout << "排序后..." <<endl;
    printArr(arr,size);
}

int main02(){
    testIntArr();
    testCharArr();
}

  • 函数模板遇上函数重载

    1. 函数模板函数的调用（本质：类型参数化）：将严格的按照类型进行匹配，不会进行自动类型转换；

    2. 普通函数的调用可能会进行隐式类型转换。

    例子：

    #include <iostream>

using namespace std;

template <typename T>
void func(T a,T b){
    cout << "模板函数调用..." <<endl;
}

void func(int a,char b){
    cout << "普通函数调用..." <<endl;
}

int main(){
    int a = 10;
    char b = 'b';

    func(a,b); // 调用普通函数
    func(b,a); // 调用普通函数
    func(a,a); // 调用模板函数
}

  • 函数模板和普通函数在一起的调用规则：

    1. 函数模板不允许自动类型转化；

    2. 普通函数能够进行自动类型转化（如果精确匹配到）；

    3. 函数模板可以像普通函数一样被重载；

    4. c++编译器优先考虑普通函数；
    5. 如果模板函数可以产生一个更好的匹配，那么选择模板函数；
    6. 可以通过空模板实参列表的语法限定编译器只通过模板匹配。

    例子：

    #include <iostream>

using namespace std;

int Max(int a,int b){
    cout << "普通函数--Max(int a,int b)..." <<endl;
    return a > b? a:b;
}

template <typename T>
T Max(T a,T b){
    cout << "模板函数--T Max(T a,T b)..." <<endl;
    return a > b? a:b;
}

template <typename T,typename K>
T Max(T a,K b){
    cout << "模板函数--T Max(T a,K b)..." <<endl;
    return a > b? a:b;
}

template <typename T>
T Max(T a,T b,T c){
    cout << "模板函数--int Max(T a,T b,T c)..." <<endl;
    return a > b? (a>c?a:c):(b>c?b:c);
}

int main(){
    int a = 10;
    int b=7;
    char c = 'c';

    int max = Max(a,b); // 调用普通函数
    cout << "max = " << max <<endl;

    max = Max(a,c); // 调用模板函数，产生了更好的匹配
    cout << "max = " << max <<endl;

    c = Max<char>('a','b'); // 显示调用函数模板
    cout << "c = " << c <<endl;

    c = Max<char>('a','b','c'); // 显示调用函数模板--重载
    cout << "c = " << c <<endl;
}

  • c++编译器模板机制剖析：

    • 原理：c++编译器在我们调用的时候添加了额外的函数（相应类型的函数）;
    • 编译器并不是把模板函数处理成能够处理任意类型的函数；
    • 编译器从模板函数通过具体类型产生不同的函数；
    • 编译器会对模板函数进行二次编译：
      • 在声明的地方对模板代码本身进行编译；
      • 在调用的地方对参替数换后的代码进行编译。

二、 类模板

  • 定义形式

    template <typename type1,typename T2,...> class class-name {
.
.
.
}

  • 类模板做函数参数（需要类型具体化）

    例子：

    #include <iostream>

using namespace std;


template <typename T>
// 模板类，本身是一个抽象类
class TemplateC{
private:
    T a;
public:
    TemplateC (T a){
        this->a = a;
    }

    void print(){
        cout << "a = " << a <<endl;;
    }
};

void useTemplateC(TemplateC<int> &c){
    c.print();
}

int main(){
    TemplateC<int> c1(10),c2(20),c3(30);
    useTemplateC(c1);
    useTemplateC(c2);
    useTemplateC(c3);
    return 0;
}

  • 类模板派生子类（普通类和类模板）

    代码：

    #include <iostream>

using namespace std;

template <typename T>
// 模板类，本身是一个抽象类
class TemplateC{
protected:
    T a;
public:
    TemplateC (T a){
        this->a = a;
    }

    void print(){
        cout << "a = " << a <<endl;;
    }
};

// 必须给定泛型类型，因为c++编译器要知道如何分配内存
class B : public TemplateC<int>{
private:
    int b;
public:
    B(int a,int b) : TemplateC(a){
        this->b = b;
    }

    void printB(){
        cout << "a = " <<a<<endl;
        cout << "b = "<<b<<endl;
    }
};

int main(){
    B b(10,20);
    b.printB();
}

类模板的几种写法

  • 所有类成员函数都写在类内部（推荐）

    代码：

    #include <iostream>

using namespace std;

template <typename T,typename K>
class Complex{
    // 友元函数的函数体也可以写在类外部
    friend ostream & operator<<(ostream &out,Complex &c){
        out << c.a << "+" << c.b << "j" <<endl;
        return out;
    }
public:
    Complex(T a,K b){
        this->a = a;
        this->b = b;
    }

    void print(){
        cout << a << "+" << b << "j" <<endl;
    }

    // 重载加法运算符
    Complex operator+(Complex c2){
        Complex tmp(this->a+c2.a,this->b+c2.b);
        return tmp;
    }

private:
    T a;
    K b;
};

int main(){
    Complex<int,int> c1(1,2),c2(1,3);
    c1.print();

    Complex<int,int> c3 = c1 + c2;

    // 需要重载<<操作符,重载<< >>只能用友元函数
    cout << c3 <<endl;
}

  • 所有类成员函数都写在类外部

    
#include <iostream>



using namespace std;

template <typename T,typename K>
class Complex{
    // 友元函数的函数体也可以写在类外部
    friend ostream & operator<<(ostream &out,Complex<T,K> &c);
public:
    Complex(T a,K b);

    void print();

    // 重载加法运算符
    Complex operator+(Complex c2);

private:
    T a;
    K b;
};

template <typename T,typename K>
Complex<T,K>::Complex(T a,K b){
    this->a = a;
    this->b = b;
}

template <typename T,typename K>
void Complex<T,K>::print(){
    cout << a << "+" << b << "j" <<endl;
}

template <typename T,typename K>
Complex<T,K> Complex<T,K>::operator+(Complex c2){
    Complex tmp(this->a+c2.a,this->b+c2.b);
    return tmp;
}

template <typename T,typename K>
ostream & operator<<(ostream &out,Complex<T,K> &c){
    out << c.a << "+" << c.b << "j" <<endl;
    return out;
}

int main(){
    Complex<int,int> c1(1,2),c2(1,3);
    c1.print();

    Complex<int,int> c3 = c1 + c2;

    // 需要重载<<操作符,重载<< >>只能用友元函数
    cout << c3 <<endl;
}

  • 所有类成员函数都写在类内部（类的声明(h)和实现(cpp)分开)（推荐）

    Complex.h

    
#pragma once // 保证该文件只会被包含一次


#include <iostream>



using namespace std;

template <typename T,typename K>
class Complex{
    // 友元函数的函数体也可以写在类外部
    friend ostream & operator<<(ostream &out,Complex<T,K> &c);
public:
    Complex(T a,K b);

    void print();

    // 重载加法运算符
    Complex operator+(Complex c2);
private:
    T a;
    K b;
};

    Complex.cpp

    
#include "Complex.h"


template <typename T,typename K>
Complex<T,K>::Complex(T a,K b){
    this->a = a;
    this->b = b;
}

template <typename T,typename K>
void Complex<T,K>::print(){
    cout << a << "+" << b << "j" <<endl;
}

template <typename T,typename K>
Complex<T,K> Complex<T,K>::operator+(Complex c2){
    Complex tmp(this->a+c2.a,this->b+c2.b);
    return tmp;
}

template <typename T,typename K>
ostream & operator<<(ostream &out,Complex<T,K> &c){
    out << c.a << "+" << c.b << "j" <<endl;
    return out;
}

    测试代码

    
#include <iostream>


#include "Complex.h"


using namespace std;

int main(){
    Complex<int,int> c1(1,2),c2(1,3);
    c1.print();

    Complex<int,int> c3 = c1 + c2;

    // 需要重载<<操作符,重载<< >>只能用友元函数
    cout << c3 <<endl;
}
宿罪
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
函数模板
chongchujianghu3的博客
02-13 133
参考资料 函数模板 思考：如果重载的函数，其解决问题的逻辑是一致的、函数体语句相同，只是处理的数据类型不同，那么写多个相同的函数体，是重复劳动，而且还可能因为代码的冗余造成不一致性。 解决：使用模板 例：求绝对值函数的模板 函数模板定义语法 语法形式： template <模板参数表> 函数定义 模板参数表的内容 类型参数：class（或typename）...
用函数实现加法运算
weixin_53525694的博客
09-04 1135
用函数实现加法运算(函数）
【C++】模板
Suk_god的博客
03-30 677
模板相关知识的总结
第三篇 | C语言中利用函数实现加法运算
qq_58476985的博客
04-30 5659
代码展示： //利用函数实现加法运算 /*程序包含两个函数，主函数main和用户自定义函数add. 两个变量的加法运算不是通过表达式完成的，而是调用函数add实现的*/ #include<stdio.h> int add(int x,int y) /*定义add函数，add函数的形式 参数x，y为int型，返回值为int型 */ { int z; z=x+y; //计算x+y的值，并赋给z return(z); /*从add函数返回调用处， z为返回...
C++函数模板和类模板
Gefangenes的博客
06-25 1212
和其他类模板一样，派生类模板Derived在定义对象时需要明确给出派生类模板中类型参数所指代的实际数据类型。编译器在编译到使用类模板定义对象语句时，将首先按照所给定的实际数据类型对类模板进行实例化，生成一个实例类。在编译到派生类Derived的定义代码时，编译器将按照所给定的实际数据类型double对类模板Base进行实例化，生成一个double型的实例类，最终派生类Derived继承的是该实例类。使用类模板定义对象时，需要明确给出类模板中类型参数所指代的实际数据类型。o1(10.5,6);
C++函数模板（模板函数）详解
热门推荐
low5252的博客
07-04 10万+
C++函数模板（模板函数）详解定义用法：函数模板的原理延申用法2.1为什么需要类模板2.2单个类模板语法2.3继承中的类模板语法案例1：案例2：2.4类模板的基础语法2.5类模板语法知识体系梳理1.所有的类模板函数写在类的内部复数类：2.所有的类模板函数写在类的外部，在一个cpp中2.5总结关于类模板的几点说明：2.6类模板中的static关键字案例2：以下来自：C++类模板遇上static关键字...
C++模板(函数模板/类模板)
qq_61386381的博客
07-27 1万+
Ⅰ、编程 Ⅱ、函数模板 1、函数模板概念 2、函数模板格式 3、函数模板的原理 4、函数模板的实例化 1.隐式实例化 2.显示实例化 5、模板参数的匹配原则 ​编辑补充：函数不一定都能推演，但是类模板一定要指定 Ⅲ、类模板 1、类模板的定义格式 2、类模板的实例化 3、类外定义类模板参数 4、模板的分离编译......
C++函数模板和类模板的声明和定义问题
weixin_47266712的博客
08-15 2905
编译器并不是把函数模板处理成能够处理任意类的函数；编译器从函数模板通过具体类型产生不同的函数；编译器会对函数模板进行两次编译：在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译。在对模板进行声明和定义的时候，通常都会将声明和定义分开书写，在.h文件里声明，在.cpp文件里定义，最后在main函数里包含.h头文件，但这样会报链接错误。...
【C++】函数模板&类模板
m0_61151031的博客
05-18 2572
模板的概念： C++除了面向对象编程的编程思想，还有一种编程思想就是泛型编程，泛型编程的具体例子就是模板。所谓模板，就是一个通用的类型，我们可以向模板传递不同的数据类型，从而得到不同的具体类型。C++中提供的模板有函数模板和类模板； 函数模板： 函数模板定义： 函数模板的作用就是将函数的数据类型参数化，什么意思，就是我们平常写的函数都是具体有形参类型，返回类型，里面具体数据类型的。类型参数化可以在我们写函数时将这些数据类型变成未知的变量，从而得到一个函数模板，我们可以根据传入不同的数据类型得到不同.
C++函数模板特化，类模板特化
小米子的成长日记
07-09 3009
C++中模板分为函数模板和类模板所谓特化，就是将泛型的东西搞得具体化一些，从字面上来解释，就是为已有的模板参数进行一些使其特殊化的指定，使得以前不受任何约束的模板参数，或受到特定的修饰（例如const或者摇身一变成为了指针之类的东东，甚至是经过别的模板类包装之后的模板类型）或完全被指定了下来。针对特化的对象不同，分为两类：函数模板的特化和类模板的特化1. 函数模板的特化当函数模板需要对某些类型进行特化处理，称为函数模板的特化。2. 类模板的特化当类模板内需要对某些类型进行特别处理时，使用类模板的特化。3.
c++函数模板和类模板计实验报告
04-26
C++中的函数模板和类模板是泛型编程的重要组成部分，它们允许我们编写更为通用的代码，从而能够处理不同数据类型的对象。在这个实验报告中，我们将深入理解这些概念，并通过具体的编程实践来掌握它们。 首先，我们...
C++的函数模板和类模板
12-22
函数模板和普通函数区别结论： 　函数模板不允许自动类型转化 　普通函数能够进行自动类型转换 　函数模板和普通函数在一起，调用规则： 　1 函数模板可以像普通函数一样被重载 　2 C++编译器优先考虑普通函数 ...
C++函数模板与类模板实例解析
09-04
C++函数模板与类模板实例解析 C++函数模板与类模板实例解析是指C++编程语言中的一种编程范式，通过将类型参数化来实现在同一份代码上操作多种数据类型。泛型编程最初诞生于C++中，目的是为了实现C++的STL（标准模板...
详解C++函数模板与分离编译模式
08-18
"详解C++函数模板与分离编译模式" C++函数模板是一种非常强大的功能，它允许开发者编写通用的代码，使得程序更加灵活和可重用。然而，在使用函数模板时，需要注意分离编译模式下的问题。在此文章中，我们将详解C++...
MFC常用数据类型类：CRect
qingttqing的博客
07-12 684
MFC数据类型类：CRect
函数模板与类模板
程序员_小兵
07-12 1288
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
C++ 多态
wxk2227814847的博客
07-10 756
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
初始C++
2302_81016149的博客
07-08 797
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
Linux C | 管道open打开方式
最新发布
I_feige的博客
07-12 206
1.
C++ PPT第8章 模板.ppt
05-30
在C++中，有两种主要类型的模板：函数模板和类模板。 函数模板，如上面的例子所示，提供了一种方式来定义一个通用的函数，该函数可以接受不同类型的参数。在`template<typename T>`中，`T`是一个类型参数，它代表...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值