当前位置： 首页 > news >正文

C++学习8-C++提高编程

news 2025/7/18 3:29:09

文章目录

  • 前言
  • 一、模板
    • 1.1 模板的概念
    • 1.2 函数模板
      • 1.2.1 函数模板语法
      • 1.2.2 函数模板注意事项
      • 1.2.3 函数模板案例
  • 复习：计算数组长度
      • 1.2.4 普通函数与函数模板的区别
      • 1.2.5 普通函数与函数模板的调用规则
      • 1.2.6 模板的局限性
    • 1.3 类模板
      • 1.3.1 类模板语法
      • 1.3.2 类模板与函数模板区别
      • 1.3.3 类模板中成员函数创建时机
      • 1.3.4 类模板对象做函数参数
      • 查看模板参数类型的方法
  • 1.3 后续部分待学（应该暂时用不到，还有需要复习一下类和对象的知识）
      • 1.3.5 类模板与继承
      • 1.3.6 类模板成员函数类外实现
      • 1.3.7 类模板分文件编写
      • 1.3.8 类模板与友元
      • 1.3.9 类模板案例
  • 二、STL初识
    • 2.1 STL的诞生
    • 2.2 STL基本概念
    • 2.3 STL六大组件
    • 2.4 STL中容器、算法、迭代器
  • 总结 #pic_center

前言

只是为方便学习，不做其他用途，原作者为黑马程序员
B站配套视频：
https://www.bilibili.com/video/BV1et411b73Z

本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨C++更深层次的使用

一、模板

1.1 模板的概念

模板就会通用的模具，大大提高复用性。

例如生活中的一寸照片、PPT模板。

在这里插入图片描述
在这里插入图片描述

模板特点：

  • 模板不可以直接使用，它只是一个框架
  • 模板的通用并不是万能的

1.2 函数模板

  • C++另一种编程思想称为泛型编程，主要利用的技术就是模板
  • C++提供两种模板机制，函数模板和类模板。

1.2.1 函数模板语法

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

语法 ：

template<typename T>
函数声明或定义

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

在这里插入图片描述

#include<iostream>
using namespace std;//函数模板
//两个整型交换
void  SwapInt(int& a, int& b)
{int temp = b;b = a;a = temp;
}
//两个浮点型交换
void SwapDouble(double& a, double& b)
{double temp = a;a = b;b = temp;
}//函数模板
//声明一个模板,告诉编译器后面的代码中紧跟着的T不要报错，T是一个通用数据类型
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 << endl;cout << b << endl;double c = 11.1;double d = 12.2;//2.显示指定类型MySwap<double>(c, d);cout << c << endl;cout << d << endl;
}
int main(void)
{test01();system("pause");return 0;
}

1.2.2 函数模板注意事项

注意事项:

  • 自动类型推导，必须推导出一致的数据类型T,才可以使用
  • 模板必须要确定出T的数据类型，才可以使用

示例:

#include<iostream>
using namespace std;//利用模板提供通用的交换函数
template<class 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';mySwap(a, b); // 正确，可以推导出一致的T//mySwap(a, c); // 错误，推导不出一致的T类型
}// 2、模板必须要确定出T的数据类型，才可以使用
template<class T>
void func()
{cout << "func 调用" << endl;
}void test02()
{//func(); //错误，模板不能独立使用，必须确定出T的类型func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板
}int main() {test01();test02();system("pause");return 0;
}

总结：使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

1.2.3 函数模板案例

案例描述：

  • 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
  • 排序规则从大到小，排序算法为选择排序
  • 分别利用char数组和int数组进行测试

示例：

#include<iostream>
using namespace std;
//实现通用 对数组进行排序的函数
//规则 从大到小
//算法 选择 
//测试 char 数组 int 数组
//交换的函数模板
template<class T>
void mySwap(T& a, T& b)
{T temp = a;a = b;b = temp;
}template<class 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++){//认定的最大值比遍历出的数值要小，说明j下标的元素才是真正的最大值if (arr[max] < arr[j]){max = j;}}if (max != i){//交换max和i元素mySwap(arr[max], arr[i]);}}
}//打印数组模板
template<class T>
void myPrint(T arr[], int len)
{for (int i = 0; i < len; i++){cout << arr[i] << " ";}cout << endl;
}void test01()
{char charArr[] = "badcfe";int num = sizeof(charArr) / sizeof(char);mySort(charArr, num);myPrint(charArr, num);
}
void test02()
{int intArr[] = { 2,3,5,9,7,1,4,8,6 };int num = sizeof(intArr) / sizeof(int);mySort(intArr, num);myPrint(intArr, num);
}
int main(void)
{test01();test02();return 0;
}

复习：计算数组长度

在这里插入图片描述

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

普通函数与函数模板区别：

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

隐式类型转换的理解：
在这里插入图片描述
在这里插入图片描述

#include<iostream>
using namespace std;
//普通函数与函数模板的区别
//普通函数调用可以发生隐式类型转换
//函数模板用自动类型推导不可以发生隐式类型转换
// 函数模板用显式指定类型 可以发生隐式类型转换//普通函数隐式类型转换
int myAdd01(int a, int b)
{return a + b;
}//函数模板
template<class 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码 99cout << myAdd01(a, c) << endl;//自动类型推导不行//cout << myAdd02(a, c) << endl;//显式指定类型行cout << myAdd02<int>(a, c) << endl;
}int main(void)
{test01();system("pause");return 0;
}

总结:建议使用显式指定类型的方式，调用函数模板，因为可以自己确定通用类型T

1.2.5 普通函数与函数模板的调用规则

调用规则如下：

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

在这里插入图片描述

#include<iostream>
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();system("pause");return 0;
}

总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

1.2.6 模板的局限性

局限性：

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

例如 ：

	template<class 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++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

#include<iostream>
using namespace std;#include <string>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<>开头，并通过名称来指出类型
//具体化优先于常规模板
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);//自定义数据类型，不会调用普通的函数模板//可以创建具体化的Person数据类型的模板，用于特殊处理这个类型bool ret = myCompare(p1, p2);if (ret){cout << "p1 == p2 " << endl;}else{cout << "p1 != p2 " << endl;}
}int main() {test01();test02();system("pause");return 0;
}

总结 ：

  • 利用具体化的模板，可以解决自定义类型的通用化
  • 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.3 类模板

1.3.1 类模板语法

类模板作用：

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

类模板语法：

template<typename T>
类

示例：

#include<iostream>
using namespace std;#include <string>
//类模板
template<class NameType, class AgeType>
class Person
{
public:Person(NameType name, AgeType age){this->mName = name;this->mAge = age;}void showPerson(){cout << "name: " << this->mName << " age: " << this->mAge << endl;}
public:NameType mName;AgeType mAge;
};void test01()
{// 指定NameType 为string类型，AgeType 为 int类型Person<string, int>P1("孙悟空", 999);P1.showPerson();
}int main() {test01();system("pause");return 0;
}

总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板

1.3.2 类模板与函数模板区别

类模板与函数模板区别主要有两点 ：

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

在这里插入图片描述

#include<iostream>
using namespace std;#include <string>
//类模板
template<class NameType, class AgeType = int>
class Person
{
public:Person(NameType name, AgeType age){this->mName = name;this->mAge = age;}void showPerson(){cout << "name: " << this->mName << " age: " << this->mAge << endl;}
public:NameType mName;AgeType mAge;
};//1、类模板没有自动类型推导的使用方式
void test01()
{// Person p("孙悟空", 1000); // 错误 类模板使用时候，不可以用自动类型推导Person <string, int>p("孙悟空", 1000); //必须使用显示指定类型的方式，使用类模板p.showPerson();
}//2、类模板在模板参数列表中可以有默认参数
void test02()
{Person <string> p("猪八戒", 999); //类模板中的模板参数列表 可以指定默认参数p.showPerson();
}int main() {test01();test02();system("pause");return 0;
}

总结：

  • 类模板使用只能用显示指定类型方式
  • 类模板中的模板参数列表可以有默认参数

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

类模板中成员函数和普通类中成员函数创建时机是有区别的：

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才创建
#include<iostream>
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();system("pause");return 0;
}

总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建

1.3.4 类模板对象做函数参数

学习目标 ：

  • 类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

  1. 指定传入的类型 — 直接显示对象的数据类型
  2. 参数模板化 — 将对象中的参数变为模板进行传递
  3. 整个类模板化 — 将这个对象类型 模板化进行传递

查看模板参数类型的方法

在这里插入图片描述

#include<iostream>
using namespace std;#include <string>
//类模板
template<class NameType, class AgeType = int>
class Person
{
public:Person(NameType name, AgeType age){this->mName = name;this->mAge = age;}void showPerson(){cout << "name: " << this->mName << " age: " << this->mAge << endl;}
public:NameType mName;AgeType mAge;
};//1、指定传入的类型
void printPerson1(Person<string, int>& p)
{p.showPerson();
}
void test01()
{Person <string, int >p("孙悟空", 100);printPerson1(p);
}//2、参数模板化
template <class T1, class T2>
void printPerson2(Person<T1, T2>& p)
{p.showPerson();cout << "T1的类型为： " << typeid(T1).name() << endl;cout << "T2的类型为： " << typeid(T2).name() << endl;
}
void test02()
{Person <string, int >p("猪八戒", 90);printPerson2(p);
}//3、整个类模板化
template<class T>
void printPerson3(T& p)
{cout << "T的类型为： " << typeid(T).name() << endl;p.showPerson();}
void test03()
{Person <string, int >p("唐僧", 30);printPerson3(p);
}int main() {test01();test02();test03();system("pause");return 0;
}

总结：

  • 通过类模板创建的对象，可以有三种方式向函数中进行传参
  • 使用比较广泛是第一种：指定传入的类型

1.3 后续部分待学（应该暂时用不到，还有需要复习一下类和对象的知识）

1.3.5 类模板与继承

当类模板碰到继承时，需要注意一下几点：

  • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
  • 如果不指定，编译器无法给子类分配内存
  • 如果想灵活指定出父类中T的类型，子类也需变为类模板

总结：如果父类是类模板，子类需要指定出父类中T的数据类型

1.3.6 类模板成员函数类外实现

学习目标：能够掌握类模板中的成员函数类外实现

总结：类模板中成员函数类外实现时，需要加上模板参数列表

1.3.7 类模板分文件编写

学习目标：

  • 掌握类模板成员函数分文件编写产生的问题以及解决方式

问题：

  • 类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

  • 解决方式1：直接包含.cpp源文件
  • 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

总结：

1.3.8 类模板与友元

学习目标：

  • 掌握类模板配合友元函数的类内和类外实现

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

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

总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别

1.3.9 类模板案例

：

二、STL初识

2.1 STL的诞生

  • 长久以来，软件界一直希望建立一种可重复利用的东西
  • C++的面向对象和泛型编程思想，目的就是复用性的提升
  • 大多情况下，数据结构和算法都未能有一套标准,导致被迫从事大量重复工作
  • 为了建立数据结构和算法的一套标准,诞生了STL

2.2 STL基本概念

  • STL(Standard Template Library, 标准模板库)
  • STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator)
  • 容器和算法之间通过迭代器进行无缝连接。
  • STL 几乎所有的代码都采用了模板类或者模板函数

2.3 STL六大组件

STL大体分为六大组件，分别是: 容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

  1. 容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。
  2. 算法：各种常用的算法，如sort、find、copy、for_each等
  3. 迭代器：扮演了容器与算法之间的胶合剂。
  4. 仿函数：行为类似函数，可作为算法的某种策略。
  5. 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
  6. 空间配置器：负责空间的配置与管理。

2.4 STL中容器、算法、迭代器

容器：置物之所也

STL容器就是将运用最广泛的一些数据结构实现出来

常用的数据结构：数组, 链表,树, 栈, 队列, 集合, 映射表 等

这些容器分为序列式容器和关联式容器两种:

  • 序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置。
  • 关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系

总结 #pic_center

空格         空格

：

二维数
1
1
1
http://www.lryc.cn/news/44862.html

相关文章：

  • ubuntu安装git server
  • 物流云数据分析平台
  • 配置OBS存储功能、新搭建obs
  • 基于DPDK收包的suricata的安装和运行
  • 浅谈23种设计模式
  • JetBrains Rider 2022.3.3 Crack
  • 浅理解扁平数据结构转Tree（树形结构）
  • 前端开发——JavaScript的条件语句
  • 2.11 循环赛日程表
  • SpringBoot——SB整合mybatis案例(残缺版本)第三集
  • Baumer工业相机堡盟相机不满帧如何使用CameraExplorer设置相机参数让它的帧率达到满帧
  • 巴黎爱情回忆 NFT 作品集
  • openai开放gpt3.5-turbo模型api，使用python即可写一个基于gpt的智能问答机器人
  • GUI开发--LCD屏幕的使用（非第三方库）--笔记
  • CesiumForUnreal实现地形等高线效果
  • Python爬虫——Python Selenium基本用法
  • 仿真与测试：单元测试与Test Harness
  • 面试常问集锦——MySQL部分
  • 算法训练第四十四天|完全背包理论 、518. 零钱兑换 II、377. 组合总和 Ⅳ
  • 0x06多层感知机
  • HTML是什么？HTML简介
  • Linux定时服务
  • sgi_stl源码学习，官方文档3.2.3String package字符串封装，未完待续
  • 从JavaScript到Java（一）：基础知识
  • Android编舞者类Choreographer小结
  • 大专升本科难度大吗 需要考哪些科目
  • 考研复试-英语问答+解答
  • python 文件相关的操作 常用函数（读文件、写文件、文件的追加内容、修改文件内容、复制文件、按行读取文件、with open） json文件的读取
  • python 系列 06 -生成及解析二维码
  • 2023第二届中国绿色钢铁国际峰会