C++基础之杂项

本文主要是介绍C++基础之杂项，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

思维导图：

学习内容：

1. Lambda表达式

1.1 基本概念

1.2 定义格式

1.3 常用情况

二、异常处理

2.1 什么是异常处理

2.2 何时使用异常处理

2.3 异常处理的格式

2.4 异常实例

2.5 构造和析构中的异常

2.6 系统提供异常类

三、C++中文件操作

3.1 文件流对象的介绍

3.2 关于文件的操作

四、C++中线程支持

4.1 线程支持类的引入

4.2 线程的相关使用

五、模板

5.1 模板的引入

5.2 模板函数

5.3 模板函数的特化

5.4 模板类

5.5 STL标准模板库（非常重要）

5.5.1 vector动态数组

思维导图：

学习内容：

1. Lambda表达式

1.1 基本概念

lambda表达式相当于在函数中定义一个轻量版函数，可以直接使用，也可以赋值给其他函数指针变量使用

1.2 定义格式

1> 格式 : [捕获列表](函数形参列表)[mutable] [->返回值类型]{函数体内容}；

2> 解析

1、捕获列表：分为值捕获和引用捕获
值捕获：值捕获时，表达式中的数据和外界的数据属于不同的数据，并且在非mutable的lambda表达式中值捕获数据可读不可写
[变量1，变量2，。。。，变量n]：将这些数据都进行值捕获
[=]:将外界的变量全部进行值捕获
[=,&变量1，&变量2]：除了将变量1和变量2进行引用捕获外，其他都是值捕获
引用捕获：表达式中的数据和外界数据属于相同的数据，对数据操作时可读可写
[&变量1，&变量2，。。。，&变量n]：将这些数据都进行引用捕获
[&]:将外界的变量全部进行引用捕获
[&,变量1，变量2]：除了变量1和变量2是值捕获外，其他都是引用捕获
2、(函数形参列表)：表达式的形参，跟函数形参格式一致，用于外界传递数据使用
3、mutable：该关键字修饰的lambda表达式，运行对值捕获的数据进行修改
4、->返回值类型：表示lambda表达式的返回值类型，如果不写，默认为void，此时如果表达式体内，写了return，则返回结果根据return后的类型而定
一般情况下省略
5、{}：中是函数体内容
6、表达式结果后，需要使用分号结束

#include <iostream>using namespace std;//外部定义
void show()
{cout<<"hello world"<<endl;
}//auto关键字的使用
void auto_test()
{auto num = 520.0;         //让系统自动推导变量的类型//auto key = 1314, value = 20.0;   //连续定义多个变量时，不能给定不同类型的初始值//auto key;                 //使用auto自动推导时，必须指定初始值auto ptr = &num;        //此时会自动将ptr推导成指针类型auto *qtr = &num;       //跟上面的指针推导一样cout<<"*ptr = "<<*ptr<<"    *qtr = "<<*qtr<<endl;cout<<"num = "<<num<<"  sizeof(num) = "<<sizeof(num)<<"  typeid(num) = "<<typeid (num).name()<<endl;auto ref1 = num;        //定义一个普通变量ref1,初始值为numauto &ref2 = num;        //定义了num的一个引用//常用用法：一般用于循环中for(auto i=0; i<10; i++){cout<<"i = "<<i<<"   ";}cout<<endl;//注意：auto不能当作函数的形参使用}int main()
{show();    //内部调用cout<<"***************************"<<endl;int num = 520;int key = 1314;int value = 999;cout<<"main::&num = "<<&num<<endl;cout<<"main::&key = "<<&key<<endl;cout<<"main::&value = "<<&value<<endl;#if 0//定义lambda表达式:进行值捕获//auto f =  [num,key,value](string msg){       //auto f =  [=](string msg){auto f =  [num,key,value](string msg)mutable{       //mutable关键字可以取消值捕获的数据的常属性cout<<"Lambda::hello  world:"<<msg<<endl;num = 666;                //值捕获的数据可读不可写cout<<"num = "<<num<<endl;cout<<"lambda::&num = "<<&num<<endl;       //值捕获的数据和原数据不是同一个数据cout<<"lambda::&key = "<<&key<<endl;cout<<"lambda::&value = "<<&value<<endl;};
#else//定义lambda表达式：引用捕获auto f =  [&num,&key,&value](string msg){       //auto f =  [&](string msg){cout<<"Lambda::hello  world:"<<msg<<endl;num = 666;                //引用捕获的数据可读可写cout<<"num = "<<num<<endl;cout<<"lambda::&num = "<<&num<<endl;          //引用捕获和外界的数据是同一数据cout<<"lambda::&key = "<<&key<<endl;cout<<"lambda::&value = "<<&value<<endl;return 0;};#endif//调用函数f("今天天气不错");   //跟普通函数调用一致return 0;
}

1.3 常用情况

lambda表达式常用于算法的相关策略

#include <iostream>
#include<algorithm>         //算法库
//定义全局函数作为策略
int comp(int a, int b)
{return a>b;     //前面的数据大于后面的数据
}//定义仿函数当作策略
class comp1
{
public:comp1() {}int operator()(int a, int b){return a>b;}
};using namespace std;int main()
{int arr[] = {3,7,2,1,4,9,3,6};int len = sizeof(arr)/sizeof(arr[0]);    //求数组容量//将数组进行排序//sort(arr, arr+len);    //:如果不加策略，默认是升序排序//sort(arr, arr+len, comp);    //加了策略的排序函数：全局函数作为策略//sort(arr, arr+len, comp1());   //仿函数当作执行策略sort(arr, arr+len, [](int a, int b){return a>b;});   //lambda表达式当作策略//输出数据cout<<"数组中的数据为：";for(auto val:arr){cout<<val<<"  ";}cout<<endl;return 0;
}

二、异常处理

2.1 什么是异常处理

1> 异常就是程序执行过程中出现的问题

2> "异常"问题并不是经常出现

3> C语言中处理异常使用的是函数返回值完成，可以根据不同的异常返回不同的结果

4> C++中支持异常处理机制，完成一些不能使用返回值来完成的异常情况

2.2 何时使用异常处理

1> 异常处理主要解决进程同步过程中出现的异常情况，不能解决进程异步过程中的情况

2> 经常处理的错误：数组溢出、算数溢出、内存分配不足、指针越界、构造空间不足。。。

2.3 异常处理的格式

1、在可能产生异常的地方使用关键字：throw 抛出异常

2、try

        { 可能会抛出异常的语句 }

     catch(接收异常的形参)

        { 处理异常 }

注意：任何函数在定义时，可以指定能抛出的异常格式如下

返回值类型函数名(形参列表) throw(异常类型1，异常类型2，。。。。)

如果某个函数一定不会抛出异常，格式为

返回值类型函数名(形参列表) noexcept

2.4 异常实例

#include <iostream>using namespace std;//定义两数相除的函数
double division(const double &op1, const double &op2) throw(string, double)
{if(op2 == 0){throw  string("除数不能为0");      //抛出异常对象}//人为创建一个异常if(op1 == op2){throw  0.0;}return op1/op2;
}int main()
{//使用时将可能产生异常的代码放入到try中try {cout<<"结果为"<<division(1,1)<<endl;cout<<"此处省略一万行代码"<<endl;          //如果前面的代码产生异常了，后面的程序就不再执行} catch (string &e) {cout<<"异常信息："<<e<<endl;} catch(double &e){cout<<"错误值为："<<e<<endl;}cout<<"愿世界和平"<<endl;return 0;
}

2.5 构造和析构中的异常

1> 关于析构的步骤

        1、程序收到一个异常

        2、初始化异常参数

        3、将从对应的try语句块内处理异常，并调用析构函数完成对对象的析构

        4、处理最后一个catch语句

2> 自定义异常类及测试析构函数在异常中的调用

#include <iostream>using namespace std;//自定义异常类
class MyException
{
public:MyException() {}MyException(string m):err_msg(m) {}~MyException() {}string what(){return err_msg;}      //返回本次异常的错误信息private:string err_msg;
};//定义一个测试类
class Demo
{
public:Demo() {cout<<"Demo ::构造函数"<<endl;}~Demo() {cout<<"Demo ::析构函数"<<endl;}
};//定义全局函数
void fun() throw(MyException)
{Demo d;         //构造一个对象throw(MyException("抛出异常"));     //抛出自定义的异常cout<<"此处省略一万行代码"<<endl;
}int main()
{try {fun();cout<<"---------"<<__LINE__<<"---------"<<endl;} catch (MyException &e) {cout<<"异常信息："<<e.what()<<endl;}cout<<"______________愿世界和平_________________"<<endl;return 0;
}

2.6 系统提供异常类

1> 系统提供的异常类都是由 exception 类派生出来的

2> 系统的异常一般如下

#include <iostream>
#include<exception>
using namespace std;int main()
{int arr[10] = {0};int num;try {int index;cin >> index;if(index <0 || index >=10){throw out_of_range("数组下标越界");}num = arr[index];} catch (string &e) {cout<<"异常信息： "<<e<<endl;} catch(exception &e){cout<<"异常信息： "<<e.what()<<endl;}cout<<"num = "<<num<<endl;        //如果没有异常，则能够得到正确结果cout<<"——————————————愿世界和平-----------"<<endl;return 0;
}

三、C++中文件操作

3.1 文件流对象的介绍

1> C++中提供文件流对象，来完成对文件的操作

2> 对于文件的操作，使用的时 fstream 类的对象

3.2 关于文件的操作

1> 打开文件和关闭文件

1、使用fstream的有参构造函数来完成

2、使用fstream类调用无参构造实例一个文件对象调用成员函数open来完成

#if 0//方式1：使用构造函数打开文件fstream file("./test.txt", ios_base::out|ios_base::in|ios_base::trunc);//判断文件有没有打开if(!file.is_open()){cout<<"文件打开失败"<<endl;return -1;}cout<<"文件打开成功"<<endl;//关闭文件file.close();        //关闭文件
#else//方式2：使用无参构造一个文件对象，调用成员函数打开文件fstream file;         //无参构造file.open("./test.txt", ios_base::out|ios_base::in|ios_base::trunc);   //打开文件if(!file){cerr<<"文件打开失败"<<endl;return -1;}//关闭文件file.close();#endif

2> 读写内容

C++也提供了多种数据的读写

1、使用插入和提取运算符重载函数完成

#include <iostream>
#include<fstream>          //文件流对象using namespace std;int main()
{
#if 0//方式1：使用构造函数打开文件fstream file("./test.txt", ios_base::out|ios_base::in|ios_base::trunc);//判断文件有没有打开if(!file.is_open()){cout<<"文件打开失败"<<endl;return -1;}cout<<"文件打开成功"<<endl;//关闭文件file.close();        //关闭文件
#else//方式2：使用无参构造一个文件对象，调用成员函数打开文件fstream file;         //无参构造file.open("./test.txt", ios_base::out|ios_base::in|ios_base::trunc);   //打开文件if(!file){cerr<<"文件打开失败"<<endl;return -1;}//向文件中写入数据file<<"hello world"<<endl;        //使用运算符重载函数，向文件中写入一个字符串file.put('A');                  //调用成员函数向文件中写入一个字符string str = "愿世界和平";file.write(str.data(), str.length());   //使用成员函数向文件中写入一个字符串//偏移文件光标file.seekg(0, ios_base::beg);        //lseek(fd, 0, SEEK_SET);//从文件中读取数据char ch = 0;file.get(ch);            //读取一个字符cout<<"ch = "<<ch<<endl;char buf[128] = "";file.read(buf, 10);          //从文件中读取一个字符串cout<<"buf = "<<buf<<endl;//关闭文件file.close();#endifreturn 0;
}

四、C++中线程支持

4.1 线程支持类的引入

1> 需要引入类 thread

2> 所在头文件 #include

4.2 线程的相关使用

1> 创建线程：可以使用构造函数完成

注意：线程体函数，跟C语言的有所不同

也可以使用匿名对象完成构造

2> 线程体Id的获取：this_thread::get_id()

3> 线程资源回收：join()

4> 线程分离态：detach();

5> 线程体函数可以是全局函数、类中成员函数、仿函数、lambda表达式

#include <iostream>
#include<thread>         //线程支持库using namespace std;//定义线程体函数
void task()
{while(1){cout<<"我是分支线程:"<<this_thread::get_id()<<endl;    //求当前线程id号this_thread::sleep_for(chrono::seconds(2));}
}//定义线程体2
void task1(const int &num, const string &msg)
{cout<<"我是线程体2："<<"   num = "<<num<<"   msg = "<<msg<<endl;this_thread::sleep_for(chrono::seconds(5));cout<<"线程体2退出"<<endl;return;}int main()
{//实现方式1：实例化一个无参构造线程对象thread th;             //无参构造th = thread(task);          //创建一个分支线程//实现方式2：创建线程，向线程体内传参，使用有参构造完成thread th1(task1, 520, "hello");//lambda表达式当作线程体函数thread th3([](){while(1){cout<<"我是线程体3"<<endl;this_thread::sleep_for(chrono::seconds(1));}});//此处为主线程int num = 10;while(num--){cout<<"我是主线程"<<endl;this_thread::sleep_for(chrono::seconds(1));}//判断线程体1if(th.joinable()){//阻塞等待线程的结束th.join();//th.detach();    //将线程设置成分离态}if(th1.joinable()){th1.join();}if(th3.joinable()){th3.join();}cout<<"____________愿世界和平————————————————————————"<<endl;return 0;
}

五、模板

5.1 模板的引入

1> 有时候程序性定义函数或者定义类时，可能由于参数的类型不同，导致相同功能的函数或者相同功能的类需要定义多个，造成程序的冗余

2> 此时我们就可以引入模板的概念：当调用函数时或者使用类进行实例化对象时，不仅将实参值传递过去，而且也要讲类型作为参数传递过去

3> 模板分为模板函数和模板类

5.2 模板函数

1> 所谓模板函数，就是在定义函数时，函数的参数的类型和参数值都不给定，等到函数调用时，根据传进来的实参的类型和值来确定该函数的具体实现

2> 定义格式

tamplate <typename 类型参数1，typename 类型参数2，typename 类型参数n>

类型函数名(参数类型1 参数名1，参数类型2，参数名2，。。。)

{函数体内容}

3> 调用格式：

1、跟普通函数的调用一样（隐式调用）

2、调用函数时，在函数名后面使用<>给定类型参数（显式调用）

4> 同一个模板生命下，只能定义一个函数，如果要定义多个，需要声明多个模板

5> 显性调用时的原则：尖找尖圆找圆

#include <iostream>using namespace std;/*
//两整数qiu和
int sum(int m, int n)
{return m+n;
}
//两个小数求和
double sum(double m, double n)
{return m+n;
}
//两个字符串求和
string sum(string m, string n)
{return m+n;
}
*///定义模板函数
template<typename T>
T sum(T m, T n)
{return m+n;
}template<typename T>
T sum(T m, T n, T k)
{return  m+n+k;
}//与上一个模板函数构成重载关系
template <class T1, class T2>
T2 sum(T1 m, T2 n)
{return m+n;
}int main()
{cout << sum(3,7) << endl;      //10    隐士调用cout << sum<int, double>(3,7.5) << endl;      //10.7  显示调用：尖找尖  圆找圆cout << sum(string("3"),string("7")) << endl;      //37return 0;
}

5.3 模板函数的特化

1> 允许定义模板函数时，给某些参数指定类型，这样的模板就是特化模板

2> 当基础模板和特化模板同时存在时

如果时隐式调用函数，则调用的是基础模板

如果是显示调用函数，则调用的是特化模板

#include <iostream>using namespace std;//定义模板函数
template<typename T>
T sum(T m, T n)
{cout<<"_______基础模板___________"<<endl;return m+n;
}//定义特化模板
template<typename T>
T sum(int m, int n)
{cout<<"_______特化模板__________"<<endl;return m+n;
}int main()
{sum(520, 1314);        //模板函数的隐式调用时，如果基础模板和特化模板同时存在，则调用基础模板sum<double>(520,1314);    //模板函数的显示调用时，如果基础模板和特化模板同时存在，则调用特化模板return 0;
}

5.4 模板类

1> 程序员在定义类的过程中，可能会因为类型的不同，导致同一功能的类，需要定义多个

例如：定义一个链表中的节点，由于数据域类型的不同，导致节点需要定义多个

2> 定义格式

tamplate <typename 类型参数1，typename 类型参数2，typename 类型参数n>

class 类名 { 类型成员名； }

#include <iostream>using namespace std;//定义节点，使用模板类
template<typename T>
class Node
{
private:T data;            //数据域public:Node *next;              //指针域public:Node() {}Node(T d);        //类内声明~Node();           //类内声明void show();};//内外定义时，用到类名时，必须显性调用，此时需要使用一个模板，重新定义模板即可
template<typename T1>void Node<T1>::show()
{cout<<"数据域为："<<data<<endl;
}//不同的成员函数类外定义，都需要重新定义模板
template<typename T>
Node<T>::Node(T d):data(d), next(nullptr)
{}template<typename T>
Node<T>::~Node()
{}int main()
{Node<int> n1(520);             //类模板必须显式调用n1.show();Node<double> n3(520.1);             //类模板必须显式调用n3.show();Node<string> n2("hello");n2.show();Node<int> n4(1111);             //类模板必须显式调用n4.show();Node<int> *ptr = &n1;ptr->next = &n4;return 0;
}

5.5 STL标准模板库（非常重要）

C++ STL (Standard Template Library标准模板库) 是通用类模板和算法的集合，它提供给程序员一些标准的数据结构的实现如 queues(队列), lists(链表), 和 stacks(栈)等.

C++ STL 提供给程序员以下三类数据结构的实现:

顺序结构

C++ Vectors

C++ Lists

C++ Double-Ended Queues

容器适配器

C++ Stacks

C++ Queues

C++ Priority Queues

联合容器

C++ Bitsets

C++ Maps

C++ Multimaps

C++ Sets

C++ Multisets

程序员使用复杂数据结构的最困难的部分已经由STL完成. 如果程序员想使用包含int数据的stack, 他只要写出如下的代码:

stack myStack;

接下来, 他只要简单的调用 push() 和 pop() 函数来操作栈. 借助 C++ 模板的威力, 他可以指定任何的数据类型，不仅仅是int类型. STL stack实现了栈的功能，而不管容纳的是什么数据类型.

5.5.1 vector动态数组

1> 常用函数

1、构造函数 vector(); //无参构造

                        vector( size_type num, const TYPE &val ); //有参构造，使用 num个val来构造一个

                        vector vector( const vector &from ); //拷贝构造

                        vector( input_iterator start, input_iterator end ); //使用一个容器的起始位置到终止为止的内容构造一个vector

2> 实例演示

#include <iostream>
#include<vector>        //将头文件引入using namespace std;int main()
{vector<int> v1;     //定义一个存放整数的vector  无参构造//判空函数 emptyif(v1.empty()){cout<<"v1 is empty"<<endl;}else{cout<<"v1 is  not empty"<<endl;}cout<<v1.size()<<endl;           //求容器的实际大小 sizecout<<v1.capacity()<<endl;        //求当前容器的最大容量 capacityfor(int i=0; i<20; i++){v1.push_back(i+1);              //向容器尾部进行放入数据 push_backcout<<"size = "<<v1.size()<<"     capacity = "<<v1.capacity()<<endl;}//遍历当前的容器 方式1cout<<"默认容器中的数据分别时：";for(auto val:v1){cout<<val<<"  ";}cout<<endl;//遍历当前的容器 方式2cout<<"默认容器中的数据分别时：";for(unsigned int i=0; i<v1.size(); i++){cout<<v1[i]<<"  ";              //该容器中重载了 [] 括号运算符}cout<<endl;//遍历当前的容器 方式3cout<<"默认容器中的数据分别时：";for(unsigned int i=0; i<v1.size(); i++){cout<<v1.at(i)<<"  ";              //访问成员函数 at}cout<<endl;//访问第一个元素cout<<"v1[0] = "<<v1[0]<<"  "<<v1.at(0)<<"  "<<v1.front()<<endl;    //front函数//访问最后一个元素cout<<"最后一个元素："<<v1.back()<<endl;                       //back函数//删除最后一个元素v1.pop_back();          //pop_backcout<<"默认容器中的数据分别时：";for(unsigned int i=0; i<v1.size(); i++){cout<<v1.at(i)<<"  ";              //访问成员函数 at}cout<<endl;//清空容器的内容v1.clear();cout<<v1.size()<<endl;           //求容器的实际大小 sizecout<<v1.capacity()<<endl;        //求当前容器的最大容量 capacitycout<<"*************************************************"<<endl;//使用有参构造，构造一个容器vector<string> v2(5, "hello");cout<<"此时容器中的数据分别时：";for(auto val:v2){cout<<val<<"  ";}cout<<endl;cout<<v2.size()<<endl;           //求容器的实际大小 size   8cout<<v2.capacity()<<endl;        //求当前容器的最大容量 capacity//向容器中增加数据for(int i=0; i<20; i++){v2.push_back("nihao");              //向容器尾部进行放入数据 push_backcout<<"size = "<<v2.size()<<"     capacity = "<<v2.capacity()<<endl;}cout<<"*************************************************"<<endl;//使用一个容器的范围内的数据给另一个容器初始化int arr[10] = {1,2,3,4,5,6,7,8,9,10};vector<int> v3(arr+2, arr+8);     //将[arr+2,arr+8)的所有数据给v3初始化cout<<"此时容器中的数据分别时：";for(auto val:v3){cout<<val<<"  ";}cout<<endl;v3.swap(v1);          //交互两个容器的内容for(auto val:v1){cout<<val<<"  ";}cout<<endl;return 0;
}

这篇关于C++基础之杂项的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！