C++学习笔记（9）：模板

最新推荐文章于 2023-06-13 18:12:57 发布
最新推荐文章于 2023-06-13 18:12:57 发布
阅读量792 收藏 1
点赞数 1
分类专栏： C++学习笔记相关 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hankerchen/article/details/121479429
版权

文章目录


本博文是学习黑马程序员C++视频时做的笔记，记录一下只是方便温故知新，不做其他用途。

一、模板的概念

1、模板的特点：
（1）不可以直接使用，它只是一个模板；
（2）模板的通用不是万能的。
2、C++提供两种模板机制：
（1）函数模板；
（2）类模板。

二、函数模板

2.1 函数模板的基本语法

语法：

template<typename T>

模板有两种使用方法：
（1）自动推导类型，例如myswap(a,b);
（2）显示指定类型，例如myswap(a,b);

#include<iostream>
#include<string>
using namespace std;

//模板的基本语法
template<typename T>//声明模板
void myswap(T &a,T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

void test01()
{
    int a = 10;
    int b = 20;
//    两种方式使用函数模板
//    1 自动推导类型
//    myswap(a,b);
//    cout<<"a = "<<a<<endl;
//    cout<<"b = "<<b<<endl;
//    2 显示指定类型
    myswap<int>(a,b);
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
}

int main()
{
    test01();
    return 0;
}

在这里插入图片描述

2.2函数模板的注意事项

（1）自动推导类型，必须推导出一致的数据类型T才可以使用
（2）模板必须确定出T的数据类型才可以使用。

#include<iostream>
#include<string>
using namespace std;

//模板的注意事项
template<typename T>//声明模板
void myswap(T &a,T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
//1、自动推导类型，必须推导出一致的数据类型T才可以使用
void test01()
{
    int a = 10;
    int b = 20;
    char c = 'c';
//    两种方式使用函数模板
//    1 自动推导类型
    myswap(a,b);//正确
//    myswap(a,c);//报错，类型不一致
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;

}
//2、模板必须确定出T的数据类型才可以使用。
template<typename T>
void func()
{
    cout<<"func 调用"<<endl;
}
void test02()
{
//    func();//错误
    func<int>();//正确，指定函数模板的数据类型为int。
}


int main()
{
    test01();
    test02();
    return 0;
}

在这里插入图片描述

2.3 函数模板案例-数组的选择排序

#include<iostream>
#include<string>
using namespace std;

//交换的函数模板
template<typename T>
void mySwap(T &a, T&b)
{
    T temp = a;
    a = b;
    b = temp;
}

template<typename T>
//利用选择排序，进行对数组从大到小的排序
void mySort(T arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        int max = i; //最大数的下标
        for (int j = i + 1; j < len; j++)
        {
            if (arr[max] < arr[j])
            {
                max = j;
            }
        }
        if (max != i) //如果最大数的下标不是i，交换两者
        {
            mySwap(arr[max], arr[i]);
        }
    }
}
template<typename T>
void printArray(T arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}
void test01()
{
    //测试char数组
    char charArr[] = "bdcfeagh";
    int num = sizeof(charArr) / sizeof(char);
    mySort(charArr, num);
    printArray(charArr, num);
}

void test02()
{
    //测试int数组
    int intArr[] = {1,3,5,7,9,2,4,6,8};
    int num = sizeof(intArr) / sizeof(int);
    mySort(intArr, num);
    printArray(intArr, num);
}

int main()
{
    test01();
    test02();
    return 0;
}

在这里插入图片描述

2.4 普通模板与函数模板的区别

区别：
（1）普通函数调用时，可以发生自动类型转换（隐式类型转换）；
（2）函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换；
（3）如果利用显示指定类型的方式，可以发生隐式类型转换。

#include<iostream>
#include<string>
using namespace std;

//普通函数与函数模板区别
//1 普通函数
int myAdd01(int a, int b)
{
    return a + b;
}

//2 函数模板
template<typename T>
T myAdd02(T a, T b)
{
    return a + b;
}

//使用函数模板时，如果用自动类型推导，不会发生自动类型转换,即隐式类型转换
void test01()
{
    int a = 10;
    int b = 20;
    char c = 'c';

//    普通函数，将char类型的'c'隐式转换为int类型  'c' 对应 ASCII码 99
    cout << myAdd01(a, c) << endl; //109，正确，

//    使用自动类型推导时，不会发生隐式类型转换
//    myAdd02(a, c); // 报错，

//    显示指定类型，可以发生隐式类型转换
    cout<<myAdd02<int>(b, c)<<endl; //119，正确
}

int main()
{
    test01();
    return 0;
}

在这里插入图片描述

2.5 普通函数和函数模板的调用规则

规则：
（1）如果普通函数和函数模板都可以实现，优先调用普通函数；
（2）可以通过空模板参数列表来强制调用函数模板；
（3）函数模板也可以发生重载；
（4）如果函数模板可以产生更好的匹配，优先调用函数模板。

#include<iostream>
#include<string>
using namespace std;

//普通函数与函数模板调用规则
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;
}

void test01()
{
    //1、如果函数模板和普通函数都可以实现，优先调用普通函数
    // 注意 如果告诉编译器  普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到
    int a = 10;
    int b = 20;
    myPrint(a, b); //调用普通函数

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

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

    //4、 如果函数模板可以产生更好的匹配,优先调用函数模板
    char c1 = 'a';
    char c2 = 'b';
    myPrint(c1, c2); //普通函数和重载函数的匹配度不如函数模板，调用函数模板
}

int main() 
{
    test01();
    return 0;
}

在这里插入图片描述

2.6 函数模板的局限性

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

#include<iostream>
#include<string>
using namespace std;

//模板的局限性
//模板并不是万能的，有些特定数据类型，需要具体化方式特殊实现

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

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


//具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
//可以创建具体化的Person数据类型的模板，用于特殊处理这个类型，具体化优先调用
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 test01()
{
    int a = 10;
    int b = 20;
    //内置数据类型可以直接使用通用的函数模板
    bool ret = myCompare(a, b);
    if (ret)
    {
        cout << "a == b " << endl;
    }
    else
    {
        cout << "a != b " << endl;
    }
}

void test02()
{
    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()
{
    test01();
    test02();
    return 0;
}

在这里插入图片描述

三、类模板

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

3.1 类模板语法

template<typename T>
类

其中，
● template — 声明创建模板；
● typename — 表面其后面的符号是一种数据类型，可以用class代替；
● T — 通用的数据类型，名称可以替换，通常为大写字母。

#include<iostream>
#include<string>
using namespace std;

//类模板
template<class NameType,class AgeType>
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    void ShowPerson()
    {
        cout<<"naem:"<< this->m_Name<<"age:"<< this->m_Age<<endl;
    }
    NameType m_Name;
    AgeType m_Age;
};

void test01()
{
//    调用时，指定name、age为string，int类型。
    Person<string,int>p1("孙悟空",999);
    p1.ShowPerson();
}

int main()
{
    test01();
    return 0;
}

在这里插入图片描述

3.2 类模板与函数模板的区别

区别：
1、类模板没有自动类型推导的使用方式；
2、类模板在模板参数列表中可以有默认参数。

#include<iostream>
#include<string>
using namespace std;

//类模板与函数模板区别
template<class NameType,class AgeType = int>//类模板在模板声明中可以指定默认参数，如class AgeType = int
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    void ShowPerson()
    {
        cout<<"naem:"<< this->m_Name<<"age:"<< this->m_Age<<endl;
    }
    NameType m_Name;
    AgeType m_Age;
};

//1、类模板没有自动类型推导的使用方式；
void test01()
{
//    Person p("孙悟空",999);//报错，无法自动推导类型
//    类模板调用时，指定name、age为string，int类型。
    Person<string,int>p1("孙悟空",999);
    p1.ShowPerson();
}
//2、类模板在模板参数列表中可以有默认参数。
void test02()
{
    Person<string>p2("猪八戒",1000);
    p2.ShowPerson();
}
int main()
{
    test01();
    test02();
    return 0;
}

在这里插入图片描述

3.3 类模板成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：
1、普通类中的成员函数一开始就可以创建；
2、类模板中的成员函数在调用时才创建。

#include<iostream>
#include<string>
using namespace std;

class Person1
{
public:
    void ShowPerson1()
    {
        cout << "Person1 show" << endl;
    }
};

class Person2
{
public:
    void ShowPerson2()
    {
        cout << "Person2 show" << endl;
    }
};

template<class T>
class MyClass
{
public:
    T obj;
    //类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成
    void fun1()
    {
        obj.ShowPerson1();
    }
    void fun2()
    {
        obj.ShowPerson2();
    }

};

void test01()
{
    MyClass<Person1> m;
    m.fun1();
//    m.fun2();//编译会出错，说明函数调用才会去创建成员函数
}

int main()
{
    test01();
    return 0;
}

在这里插入图片描述

3.4 类模板对象做函数参数

一共有三种传入方式:
1、指定传入类型——直接显示对象的数据类型；
2、参数模板化——将对象中的参数变为模板进行传递；
3、整个参数类模板化——将这个对象模板化进行传递。

#include<iostream>
#include<string>
#include<typeinfo>
using namespace std;
//类模板对象做函数参数
//1、指定传入类型——直接显示对象的数据类型；
//2、参数模板化——将对象中的参数变为模板进行传递；
//3、整个参数类模板化——将这个对象模板化进行传递。
template<class T1,class T2>
class Person
{
public:
    Person(T1 name,T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    void ShowPerson()
    {
        cout<<"姓名："<< this->m_Name<<"年龄"<< this->m_Age<<endl;
    }
    T1 m_Name;
    T2 m_Age;
};

//1 指定传入类型
void printPerson01(Person<string,int>&p)
{
    p.ShowPerson();
}
void test01()
{
    Person<string,int>p("孙悟空",100);
    printPerson01(p);
}

//2 参数模板化
template<class T1,class T2>
void printPerson02(Person<T1,T2>&p)
{
    p.ShowPerson();
//    cout<<"T1的类型为:"<<typeid(T1).name()<<endl;
//    cout<<"T2的类型为:"<<typeid(T2).name()<<endl;
}
void test02()
{
    Person<string,int>p("猪八戒",101);
    printPerson02(p);
}

//3 整个类模板化
template<class T3>
void printPerson03(T3 &p)
{
    p.ShowPerson();
//    cout<<"T3的类型为:"<<typeid(T3).name()<<endl;
}
void test03()
{
    Person<string,int>p("唐僧",33);
    printPerson03(p);
}
int main()
{
    test01();
    test02();
    test03();
    return 0;
}

在这里插入图片描述

3.5 类模板与继承

当类模板碰到继承时，需要注意一下几点：
1、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型；
2、如果不指定，编译器无法给子类分配内存；
3、如果想灵活指定出父类中T的类型，子类也需变为类模板。

#include<iostream>
#include<string>
#include<typeinfo>
using namespace std;

//类模板与继承
template<class T>
class Base
{
    T m;
};
//1 必须知道父类中的T类型，才能继承给子类
//class Son: public Base//报错，如果不指定，编译器无法给子类分配内存；
class Son: public Base<int>
{

};

void test01()
{
    Son s1;
}

//2 如果想灵活地指定父类中T数据类型，子类也需要变为类模板
template<class T1,class T2>
class Son2: public Base<T2>
{
public:
    Son2()
    {
        cout<<"T1的类型为:"<<typeid(T1).name()<<endl;
        cout<<"T2的类型为:"<<typeid(T2).name()<<endl;
    }
    T1 obj;
};

void test02()
{
    Son2<int,char>s2;
}

int main()
{
    test01();
    test02();
    return 0;
}

在这里插入图片描述

3.6 类模板成员类外实现

#include<iostream>
#include<string>
using namespace std;

//类模板成员函数类外实现
template<class T1,class T2>
class Person
{
public:
//    成员函数类内声明
    Person(T1 name,T2 age);
    void showPerson();
//    Person(T1 name,T2 age)
//    {
//        this->m_Name = name;
//        this->m_Age = age;
//    }
//    void showPerson()
//    {
//        cout<<"Name:"<< this->m_Name<<"Age:"<< this->m_Age<<endl;
//    }
    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<<"Name:"<< this->m_Name<<"Age:"<< this->m_Age<<endl;
}

void test01()
{
    Person<string,int>p("Tom",20);
    p.showPerson();
}
int main()
{
    test01();
    return 0;
}

在这里插入图片描述

3.7 类模板分文件编写

● 存在问题：
类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到。
● 解决方法：
解决方式1：直接包含.cpp源文件；
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制。

person.hpp文件中内容

// Created by chenhong on 2021/11/24.
//

#ifndef CLIONPROJECTS_PERSON_H
#define CLIONPROJECTS_PERSON_H

#endif //CLIONPROJECTS_PERSON_H

#pragma once
#include <iostream>
using namespace std;
#include <string>

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;
}

在这里插入图片描述

类模板分文件中的.cpp代码

#include<iostream>
#include<string>
using namespace std;

//#include "person.h"
//#include "person.cpp" //解决方式1，包含cpp源文件(不常用)

//解决方式2，将声明和实现写到一起，文件后缀名改为.hpp（常用）
#include "person.hpp"

void test01()
{
    Person<string,int>p("Jerry",18);
    p.showPerson();
}
int main()
{
    test01();
    return 0;
}

在这里插入图片描述

3.8 类模板与友元

1、全局函数类内实现 - 直接在类内声明友元即可；
2、全局函数类外实现 - 需要提前让编译器知道全局函数的存在。

#include <iostream>
using namespace std;

//2.3局函数类外实现的声明，提前让编译器知道Person类
template<class T1, class T2>
class Person;

//2.2全局函数的类外实现
template<class T1,class T2>
void printPerson2(Person<T1,T2>p)
{
    cout<<"全局函数类外实现——姓名："<<p.m_Name<<"年龄："<<p.m_Age<<endl;
}

//通过全局函数打印Person信息
template<class T1,class T2>
class Person
{
//    1.1 全局函数配合友元 类内实现
    friend void printPerson(Person<T1,T2>p)
    {
        cout<<"姓名："<<p.m_Name<<"年龄"<<p.m_Age<<endl;
    }
//    2.1 全局函数配合友元 类外实现 
    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.2 测试
void test01()
{
    Person<string,int>p1("Tom",20);
    printPerson(p1);

}

//2.4 测试
void test02()
{
    Person<string,int>p2("Tim",22);
    printPerson2(p2);

}

int main()
{
    test01();
    test02();
    return 0;
}

在这里插入图片描述

Hankerchen
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++STL学习笔记.pdf
05-23
关于学习C++《STL模板库》以及学习《STL源码剖析》的学习笔记。
LearningNote:C++和Linux学习笔记
05-03
这个仓库中 、 是秋招过程中的总结，其余几个类别是学习过程中琐事总结。以下是自己学习过程中收集的视频资源： 后续更新： 学习路线 深入了解 Modern C++ 裸数组传入模板函数，退化还是不退化 auto与函数模板之推导...
C/C++编程笔记：C++模板详解（一）函数模板的概念和特性
致力于C语言C++知识分享！
03-31 367
函数模板是指这样的一类函数：可以用多种不同数据类型的参数进行调用，代表了一个函数家族。它的外表和普通的函数很相似，唯一的区别就是：函数中的有些元素是未确定的，这些元素将在使用的时候才被实例化。先来看一个简单的例子： 一、定义一个简单的函数模板 下面的这个例子就定义了一个模板函数，它会返回两个参数中最大的那一个： 这个函数模板定义了一个“返回两个值中最大者”的函数家族，而参数的类型还没有确...
C++学习笔记 （四）模板
是鲤鱼啊
01-26 151
一.函数模板 c++的一个编程思想就是面向对象，另一种就是泛型编程，主要利用的就是模板。有两种，函数模板与类模板。 函数模板的作用：先建立一个通用函数，其返回值类型与参数类型都不具体制定，而是用一个虚拟的类型表示。 1.普通函数与函数模板的区别 2.普通函数与函数模板的调用规则 注：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性。 3.模板的局...
c++模板笔记
qq_40140790的博客
11-22 187
目录 模板编译机制： 模板分为函数模板和类模板： 类模板： 函数模板： 非类型参数： 默认模板参数： 成员模板： 实例化控制： 类型转换： 函数显示模板实参： 尾置转换参数： 可变长度参数： 扩展包： 特例化模板： 模板编译机制： 编译器遇到一个模板时不会产生参数，不会产生模板，直到运行期给模板参数，这时编译器就会产生相应的函数代码，这称之为实例化。只有模板实例化出...
C++模板笔记
web17886480312的博客
03-14 1241
文章目录 ???C++模板 ??泛型编程 ??泛型是什么？ ??泛型编程是什么？ ??模板 ??函数模板 ??引论 ??什么是函数模板？ ??实例 ??小结 ??模板的实例化 ??隐式实例化 ??显式实例化 ??类模板 ??引论 ??实例 ??注意点 ??总结 ???C++模板 ??泛型编程 ??泛型是什么？ 泛型是一种可以替代所有类型的通用类型 不使用具体类型，使用通用类型进行编程，模板就是一个很好的使用泛型的例子 泛型，广泛的类型 ??泛型编程是什
C++笔记--模板
ljt2724960661的博客
05-08 502
最近在复习C++的基础知识，这一节主要是模板，模板是自动生成新类型的一种机制，也是泛型编程的基础，模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。每个容器都有一个单一的定义，比如 向量，我们可以定义许多不同类型的向量，比如 vector <int> 或 vector <string>。 1 函数模板基本使用: 1.1 template<class/typename T> 告诉编译器1紧跟的代...
C++学习笔记、常见面试知识点.zip
08-04
C++学习笔记和常见面试知识点，C++11特性，包括多态、虚表、移动语义、友元函数、符号重载、完美转发、智能指针、const和static、数组指针和指针数组、struct内存对齐、enum和union关键字等等。帮助了解C++的特性，...
c++个人学习笔记归纳总结.rar_C++STL_X9H3_c++个人笔记总结
09-23
一、C++语言语法基础(6) 二、数据结构和算法 三、模板和STL 四、阶段项目
c++学习笔记（个人学习时做的笔记）
11-27
该笔记是我在mooc上看C++程序设计时做的一些笔记，因为是突发学习C++，要什么就学习什么，现在已经学到“文件输入输出流”，因为现在的项目不需要用到模板的知识，所以暂时只学到这么多，之后肯定还得学的，这个老师...
C++学习 --模板笔记
m0_72909732的博客
06-13 85
template；其中： template - 声明创建模板 class - 表明其后的符号是一种数据类型，可用typename代替 T - 通用的数据类型，名称可以替换，一般为大写字母（1）自动推导法 （2）显示指定类型 3.具体案例（利用模板创建交换两个值的函数）：
C++ 类模板 学习笔记
van9527的博客
07-11 119
C++ 类模板 学习笔记
c++模板学习笔记
对自己笑
08-29 205
一、模板定义： 模板是实现代码重用机制的一种工具，可以实现类型的参数化，即将类型作为参数，从而实现代码重用。模板分为函数模板和类模板两种。 二、函数模板 一般格式如下： Template &lt;class or typename T&gt; 返回类型 函数名（形参表） { //函数定义体 } //其中：Template为模板声明的关键字，用class或typenam...
c++ 类模板学习笔记
weixin_57651568的博客
05-29 127
学习笔记
C++学习笔记【模板】
weixin_43682638的博客
12-16 636
一、函数模板 1.函数模板的概念 template <typename T> 或 template <class T> T Add(T a,T b) 函数模板为返回值类型为T，参数类型为T，实现相加操作的函数。 { T c = a + b; return c; } 使用方式1：***自动类型推导*** int main() { int a = 10; int b = 10; char c = 'c'; cout<<Add(a,b)<<endl
c++学习笔记之类模板
u010660979的博客
02-10 107
目录 一.类模板的概述 二.类模板的实现 1.所有函数的在类的内部实现 2.所有函数在类的外部实现(同一个cpp文件) 3.所以函数在类的外部实现(分别在.h和.cpp文件中实现) 三.类模板总结 一.类模板的概述 类模板是为了让类能够兼容更多的数据类型，从而使类更具有一 般性。类模板在表示如数组，表，图等数...
C++学习笔记:模板
qq_42309130的博客
03-27 154
C++学习笔记:模板1.函数模板2.类模板2.1类模板注意事项 模板分为函数模板与类模板。 1.函数模板 函数模板可以建立一个通用的函数，其返回值和参数的类型无需提前确定，用一个虚拟的类型代表。 语法： template<typename T> //函数声明或定义 //template:表明创建一个模板 //typename:表明后面是一种数据类型 //T:通用数据类型 例程： #include <iostream> #include <string> using n
c++学习笔记—模板
ZHANjs1999的博客
10-22 112
1.模板 模板就是简历通用的模具，提高代码的复用性。 模板的特点: 模板不能直接使用 模板的通用性并不是万能的 c++提供了两种模板机制，函数模板和类模板 1.1函数模板 模板语法 template<typename T> //template 声明模板的关键字 // typename 表明后面是一种数据类型 // T通用的数据类型 T的类型是不固定的 函数声明或定义 //利用模板写交
复习笔记（八）——C++模板
别呀的博客
05-03 195
模板的概念 在C++标准库中，几乎所有的代码都是模板代码。 模板是一种参数化的多态工具。 所谓参数化的多态性，是指将程序所处理 的对象的类型参数化，使一段程序代码可以用于处理多不同类型的对象。 采用模板编程，可以为各种逻辑功能相同而数据类型不同的程序提供一种代码共享的机制。 继承和组合提供了重用对象代码的方法，而模板提供了重用源代码的方法。 函数模板 所谓函数模板，实际上是建立一个通用函数，它所用到的数据的类型（包括返回值类型、形参类型、局部变量类型）可以不具体指定，而是用一个虚拟的类型来代替（实际上是用
侯捷c++笔记stl
最新发布
08-13
你好！关于侯捷的C++笔记中的STL部分，我可以给你一些基本的信息。STL（标准模板库）是C++的一个重要组成部分，它提供了一系列的模板类和函数，用于实现常用的数据结构和算法。 STL主要包括以下几个部分： 1. 容器（Containers）：包括向量（vector）、链表（list）、集合（set）、映射（map）等，用于存储和组织数据。 2. 算法（Algorithms）：包括排序、查找、遍历等常用算法，可以用于操作容器中的数据。 3. 迭代器（Iterators）：用于访问和遍历容器中的元素。 4. 仿函数（Functors）：类似于函数的对象，可以在算法中使用。 5. 分配器（Allocators）：用于内存管理，可以自定义内存分配策略。 侯捷在他的C++笔记中对STL进行了详细的讲解和示例，包括使用各种容器、算法和迭代器等。他对STL的解释通常非常清晰，并且提供了很多实用的技巧和建议。 如果你想深入学习STL，我推荐你阅读侯捷的C++笔记中关于STL的章节，同时也可以参考C++标准库的官方文档。希望这些信息对你有帮助！如果你有其他问题，请随时问我。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值