cpp学习笔记：模板

已于 2022-11-06 20:36:21 修改
阅读量310 收藏 1
点赞数
分类专栏： cpp 文章标签： 学习
于 2022-11-04 21:43:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ohhjack/article/details/127696246
版权

一、模板的作用

建立一个通用函数，其函数返回值类型和形参类型可以不具体确定，用一个虚拟的类型来代表。

template<typename T>

二、示例

1、不使用模板写两个交换变量数值

void SwapInt(int &a,int &b)
{
    int temp=a;
    a = b;
    b = temp;
}

void SwapDouble(double &a,double &b)
{
    double temp = a;
    a = b;
    b = temp;
}


int main() 
{
    int a = 10;
    int b = 20;
    SwapInt(a, b);

    cout << a << endl;
    cout << b << endl;

    system("pause");
    return 0;
}

2、使用模板交换两个变量数值

template<typename T>
void Swap(T& a,T&b)
{
    T temp = a;
    a = b;
    b = temp;
}


int main() 
{
    int a = 10;
    int b = 20;

    Swap(a, b);      //自动推导类型
    Swap<int>(a, b); //显示指定类型

    cout << a << endl;
    cout << b << endl;

    system("pause");
    return 0;
}

三、使用模板时的注意事项

1、自动类型推导，必须推导出一致的数据类型T，才能使用

    int a = 10;
    int b = 20;
    char c = 'c';

    Swap(a, b);    //自动推导类型
    //Swap(a, c);  //报错，自动推导时类型必须相同

2、模板必须要确定出T的数据类型，才可以使用

template<typename T>
void func()
{
    cout << "111" << endl;
}


int main() 
{
    //func();    //错误，模板不能独立使用，必须确定出T的类型
    func<int>(); //利用显示置定类型的方法，给T一个类型，才可以使用模板

    system("pause");
    return 0;
}

四、函数模板案例

案例描述：

①利用函数模板封装一个排序函数，可以对不同数据类型数组进行排序

②排序规则从大到小，排序算法为冒泡排序

③分别利用char数组和int数组进行测试

template<typename T>
void Swap(T &a,T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

template<class T>
void Sort(T arr[],int len)
{
    for (int i = 0; i < len - 1;i++)
    {
        for (int j = 0; j < len - 1 - i;j++)
        {
            if(arr[j]>arr[j+1])
            {
                Swap(arr[j], arr[j + 1]);
            }
        }
    }
}

template<typename T>
void printArray(T arr[],int len)
{
    for (int i = 0; i < len;i++)
    {
        cout << arr[i] << endl;
    }
    cout << endl;
}

void text_char()
{
    char charArr[] = "qwerasd";
    int num = sizeof(charArr) / sizeof(char);
    Sort(charArr, num);
    printArray(charArr, num);
}

void text_int()
{
    int intArr[] = {7, 4, 1, 8, 5, 0, 2, 9, 6, 3};
    int num = sizeof(intArr) / sizeof(intArr[0]);
    Sort(intArr, num);
    printArray(intArr, num);
}

int main() 
{
    //text_char();
    text_int();

    system("pause");
    return 0;
}

五、普通函数与函数模板调用规则

1、如果函数模板和普通模板都可以实现，优先调用普通函数

2、可以通过空模版参数列表来强制调用函数模板

3、函数模板也可以发生重载，此时调用函数模板

4、如果函数模板可以产生更好的匹配，优先调用函数模板

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

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

template<typename T>
void myPrint(T a,T b,T c)
{
    cout << "调用重载模板" << endl;
}


int main() 
{
    int a = 10;
    int b = 20;

    //如果函数模板和普通模板都可以实现，优先调用普通函数
    myPrint(a, b);

    //可以通过空模版参数列表来强制调用函数模板
    myPrint<>(a, b);

    //函数模板也可以发生重载，此时调用函数模板
    int c = 30;
    myPrint(a, b, c);

    //如果函数模板可以产生更好的匹配，优先调用函数模板
    char c1 = 'a';
    char c2 = 'b';
    myPrint(c1, c2);

    system("pause");
    return 0;
}

六、模板的局限性

模板的通用性并不是万能的

例如：

template<typename T>
void f(T a,T b)
{
    a = b;
}

在上述代码中提供的幅值操作，如果传入的a和b是一个数组，就无法实现了。

template<class T>
void f(T a,T b)
{
    if(a>b)
    {
        
    }
}

在上述代码中，如果T的数据类型传入的是Person这样的自定义数据类型，也无法正常运行。

因此，c++提供了模板的重载，可以为这些特定类型提供具体化的模板

示例：

class Person
{
public:
    Person(string name,int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

public:
    string m_Name;
    int m_Age;
};

//普通函数模板
template<class T>
bool myCompare(T& a,T&b)
{
    if(a==b)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//具体化，显示具体化的原型和定意义以template<>开头，并通过名称来指出类型
//具体化优先于常规模板
template<> bool myCompare(Person &p1,Person &p2)
{
    if(p1.m_Name==p2.m_Name&&p1.m_Age==p2.m_Age)
    {
        return true;
    }
    else
    {
        return false;
    }
}

void text01()
{
    int a = 10;
    int b = 20;
    bool ret = myCompare(a, b);
    if(ret)
    {
        cout << "a=b" << endl;
    }
    else
    {
        cout << "a!=b"<<endl;
    }
}

void text02()
{
    Person p1("Tom", 10);
    Person p2("Tom", 10);
    bool ret = myCompare(p1, p2);
    if(ret)
    {
        cout << "p1==p2" << endl;
    }
    else
    {
        cout << "p1!=p2" << endl;
    }
}

int main() 
{
    //text01();
    text02();

    system("pause");
    return 0;
}

七、类模板

作用：建立一个通用的类，类中成员的数据类型可以不具体制定，用一个虚拟的类型来代表。

template <class NameType,class AgeType>
class Person
{
public:
    Person(NameType name,AgeType age)
    {
        this->name = name;
        this->age = age;
    }
    void showPerson()
    {
        cout << "name:" << this->name << " age:" << this->age << endl;
    }

public:
    NameType name;
    AgeType age;
};

void text01()
{
    Person<string, int> P1("猴子", 99);
    Person<int, float> P2(12, 1.11);
    P1.showPerson();
    P2.showPerson();
}

 八、类模板与函数模板的区别

类模板没有自动类型推导的使用方式，且类模板在模板参数列表中可以用默认参数

void text01()
{
    //Person p("猴子", 1000);  //类模板使用的时候，不可以用自动类型推导
    Person<string, int> p("孙悟空", 1000);  //必须使用指定的类型方式
    p.showPerson();
}

void text02()
{
    Person<string> p("猪八戒", 99);  //类模板中的模板参数列表，可以指定默认参数
    p.showPerson();
}

九、类模板中成员函数创建时机

普通类中的成员函数一开始就可以创建

类模板中的成员函数在调用时才创建

十、类模板对象做函数参数

1、指定传入的类型：直接显示对象的数据类型

void printPerson1(Person<string,int> &p)
{
    p.showPerson();
}

void text01()
{
    Person<string, int> p("孙悟空", 100);
    printPerson1(p);
}

2、参数模板化：将对象中的参数变为模板进行传递

template <class T1,class T2>
void printPerson2(Person<T1, T2>&p)
{
    p.showPerson();
}

void text02()
{
    Person <string, int> p("猪八戒", 200);
    printPerson2(p);
}

3、整个类模板化：将这个对象类型模板化进行传递

template<class T>
void printPerson3(T &p)
{
    p.showPerson();
}

void text03()
{
    Person<string, int> p("唐僧", 300);
    printPerson3(p);
}

十一、类模板与继承

1、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型

template<class T>
class Base
{
    T m;
};

//class Son:public Base     //错误，没有指出父类中T的类型
class Son:public Base<int>  //必须指定一个类型
{
};

void text01()
{
    Son s;
}

2、如果不指定，编译器无法给子类分配内存

3、如果想灵活指定出父类中T的内存，子类也需变为类模板

template<class T1,class T2>
class Son2:public Base<T2>
{
public:
    Son2()
    {
        cout << typeid(T1).name() << endl;
        cout << typeid(T2).name() << endl;
    }
};

void text02()
{
    Son2<int, char> child;
}

十二、类模板成员函数类外实现

//类模板中成员函数类外实现
template<class T1,class T2>
class Person
{
public:
    //成员函数类内声明
    Person(T1 name, T2 age);
    void showPerson();

public:
    T1 m_name;
    T2 m_age;
};

//构造函数类外实现
template <class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age)
{
    this->m_name = name;
    this->m_age = age;
}

//成员函数类外实现
template<class T1,class T2>
void Person<T1,T2>::showPerson()
{
    cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
}

void text01()
{
    Person<string, int> p("abs", 10);
    p.showPerson();
}

十三、类模板与友元

全局函数类内实现：直接在类内声明友元即可

全局函数类外实现：需要提前让编译器知道全局函数的存在

//2、全局函数配合友元 类外实现 先做函数模板声明，下方在做函数模板定义，在做友元
template <class T1, class T2>class Person;

template<class T1,class T2>
void printPerson2(Person<T1,T2> &p)
{
    cout << "类外实现 姓名:" << p.m_name << " 年龄：" << p.m_age<<endl;
}


template<class T1,class T2>
class Person
{
    friend void printPerson(Person <T1,T2> &p)
    {
        cout << "类内实现 姓名:" << p.m_name << " 年龄：" << p.m_age<<endl;
    }

    friend void printPerson2<>(Person<T1, T2> &p);

public:
    Person(T1 name,T2 age)
    {
        this->m_name=name;
        this->m_age = age;
    }

private:
    T1 m_name;
    T2 m_age;
};

//1、全局函数在类内实现
void text01()
{
    Person <string,int>p("Tom",20);
    printPerson(p);
}

//2、全局函数在类外实现
void text02()
{
    Person <string,int>p("Jerry",20);
    printPerson2(p);
}

为争。
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习笔记--函数
09-08
VS2013调试，可以直接运行。由几个例子组成，备份留作以后查看。
CPP-Learning:C ++学习笔记
03-17
1.1 CPP学习笔记 1.1.1基础入门 1.1.1.1你好，世界！ # include using namespace std ; void main () { system ( " pause " ); cout << " Hello World " < using namespace std ; // 单行注释 ...
CPP_template
weixin_34148508的博客
09-09 138
泛型编程是独立于任何特定类型的方式编写代码。模板是泛型编程的基础，模板使程序员能够快速建立具有类型安全的类库集合和函数集合，它的实现，方便了大规模的软件开发。 模板提供通用类型和通用函数，定义中包含template，和一对尖括号&lt;&gt;，尖括号里面是模板参数。模板参数与普通参数的区别在于，模板参数不仅可以传变量和值，还可以传类型。模板应放到头文件中。模板本质上就是一种宏定义。 1. 函数模...
c/cpp学习笔记
最新发布
qq_53840090的博客
04-25 931
List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容。在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容。类在设计时，可以把属性和行为放在不同的权限下，加以控制。
cpp笔记
Situo的博客
08-03 264
指针： 1、绝不要对未初始化的指针解除引用。 2、在多数情况下，数组名为第一个元素的地址，一种例外：将sizeof用于数组名时，将返回整个数组的长度。 3、可以将指针与整数相加，加1的结果等于原来的地址加上指向对象占用的总字节数。还可以减1。 4、可以将一个指针减去另一个指针，获取两个指针的差，要求两个指针指向同一个数组。 5、采用静态联编，数组的长度在编译时设置；采用动态数组，用new运算符，数组的长度将在运行时设置，即分配空间，使用完这个数组后应使用delete [] 指针名 释放其占用的内存。 6、使
CPP笔记
weixin_54025765的博客
03-19 147
cpp笔记--华为牛客题
coolq-cpp-sdk：CoolQ C ++ SDK
01-30
coolq-cpp-sdk：CoolQ C ++ SDK
CPP学习笔记dddd
02-07
C++学习笔记，类和对象，STL标准库，容器，字符串，引用，内存管理，多态
CPP学习笔记1
08-03
我日 2019.11.11 23:210.2.1.1. STL的概念0.2.1.2. 代码0.2.1.3. STL抽象的是什么0.2.2. 六大组件0.2.2.
CPP_Template:C ++项目模板
05-18
C ++模板 立即启动C ++项目 这是基于跨平台（Linux / OSX / Windows）的CMake的C ++模板，随附： 与Travis CI和Appveyor的持续集成 使用Catch进行单元测试 Doxygen的文档 CodeCov的代码覆盖率 如果需要，可以禁用/...
Cpp笔记（一）
howlowl
02-08 230
const safe: #include using namespace std; class A{ int ia; public: void setA(const int a){ ia = a; } int getA() const { /* const-safe functions: * won't change anything; * const object
[cpp]C++笔记
cn_wk的专栏
03-10 150
#include <iostream> using namespace std;int main(){ char c = 'a'; char *p; p = &c; char **q; q = &p; printf("%p\n", q); printf("%p\n", *q); printf("%c\n", **q); cout <
python类和对象理解
qq_37921925的博客
07-29 147
类似C中对结构体的定义，扩展到类和对象。 class Student //声明类类型 { public://先声明公用部分 void display() { cout<<″num:″<<num<<endl; cout<<″name:″<<name<<endl; cout<<″sex:″<<sex...
cpp学习笔记（一）
逐梦如风-毕康
09-25 1618
cpp学习笔记（一）由于已经有了一定的编程基础了，cpp的前几章节和c很像，稍微有一点点不同，因此大略的看看这些笔记是我看的书籍的大纲 ，边看书，边回想大纲里面的内容，写一些简单的测试例子基础的1-9章1 绪论 2 C++程序的组成部分 3 使用变量和常量 4 管理数组和字符串 5 使用表达式、语句和运算符 6 控制程序流程 7 使用函数组织代码 8 指针 9 引用 第一章为何c++是软件开发的标准
有关cpp的一些笔记（杂）
qq_16657927的博客
04-03 191
首先…cpp书写文件结束流的几种方法//这三种方法效果上是一样的 while(scanf("%d",&amp;n),n,m) while(scanf("%d",&amp;n)!=EOF) //EOF为文件结束流 返回值为-1 while(~scanf("%d",&amp;n))第二呢，结构体的定义方法以及排序#include&lt;bits/stdc++.h&gt; using namespace...
Cpp学习笔记1
OB杨的博客
01-21 240
变量作用域 作用域是程序的一个区域，一般来说有三个地方可以定义变量： 1.在函数或一个代码块内部声明的变量，称为局部变量。 2.在函数参数的定义中声明的变量，称为形式参数。 3.在所有函数外部声明的变量，称为全局变量。 ...
C++ 程序可以定义为对象的集合
dengjuanshou7445的博客
08-01 433
C++ 基本语法C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互。现在让我们简要地看一下什么是类、对象，方法、即时变量。 对象 - 对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。类 - 类可以定义为描述对象行为/状态的模板/蓝图。方法 - 从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中...
cpp笔记（长期更新）
weixin_30725315的博客
02-14 159
c++0x：c++11标准成为正式标准之前的草案临时名字 多态：接口的多种不同的实现方式即为多态，即子类类型的指针赋值给父类类型的指针 动态内存（堆）的管理是通过一对运算符来完成的： 　　　　new：在动态内存中为对象分配空间并返回一个指向该对象的指针，可以选择对对象进行初始化； 　　　　delete：接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。 抽象工厂...
cpp11 std::tie函数
03-27
std::tie函数是一个模板函数，用于将多个变量绑定到一个tuple中。它的原型如下： ```cpp template< class... Types > tuple<Types&...> tie( Types&... args ); ``` 使用std::tie函数可以将多个变量绑定到一个tuple中，并且可以用std::get函数从tuple中获取每个变量的值。这在函数返回多个值时非常有用。 例如，假设我们有一个函数，它返回两个值： ```cpp std::tuple<int, double> func() { return std::make_tuple(42, 3.14); } ``` 我们可以使用std::tie函数将这两个值绑定到两个变量中： ```cpp int i; double d; std::tie(i, d) = func(); ``` 这样，i和d就分别被赋值为42和3.14了。 std::tie函数还可以用于忽略某个返回值。例如，如果只需要获取第一个返回值，可以这样写： ```cpp int i; std::tie(i, std::ignore) = func(); ``` 这样，std::ignore表示忽略第二个返回值，只将第一个返回值赋值给i。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值