• C++11(下)


    一、类的新功能

    1.1 默认成员函数

    原来的C++的类中,有6个默认成员函数。

    1. 构造函数
    2. 析构函数
    3. 拷贝构造函数
    4. 拷贝赋值重载
    5. 取地址重载
    6. const 取地址重载

    最重要的是前4个,后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个:移动构造函数和移动赋值运算符重载。
    针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下:

    如果你没有自己实现移动构造函数,且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数,对于内置类型成员会执行逐成员按字节拷贝,对于自定义类型成员,则需要看这个成员是否实现移动构造,如果实现了就调用移动构造,没有实现就调用拷贝构造。

    如果你没有自己实现移动赋值重载函数,且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个,那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数,对于内置类型成员会执行逐成员按字节拷贝,对于自定义类型成员,则需要看这个成员是否实现移动赋值,如果实现了就调用移动赋值,没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)

    有人会说,这编译器默认生成的移动构造和移动赋值的条件怎么那么苛刻呢?按照其它6个默认成员函数来说,只要我们没写某一个函数,编译器就会默认生成一个对应的函数,但是对于移动构造是要求我们没写移动构造,并且我们也没写析构函数,拷贝构造,拷贝赋值重载中的任意一个时编译器才会默认生成一个移动构造函数,为什么要这么规定呢?
    原因是编译器认为只要我们写了析构函数,拷贝构造函数,拷贝赋值重载函数中的任意一个,那么我们写的这个类就是一个深拷贝的类,因为正常来说只有深拷贝的类需要自己实现析构,拷贝构造,赋值这几个函数。所以假设我们现在写了析构函数,拷贝构造和赋值,但是没写移动构造和移动赋值,如果这个时候编译器给我们默认生成一个移动构造和移动赋值,那么就会出现浅拷贝问题。
    例如现在有一个string类,这是一个深拷贝的类,我们实现了析构,拷贝构造,赋值,但是没写移动构造和移动赋值。假如编译器默认生成了移动构造,因为string类中包含的是一个char*类型的_str指针和size,capacity,都是内置类型,那么在调用移动构造时,对于内置类型是完成值拷贝,浅拷贝的,即新构造出来的string的_str和旧的string的_str指向同一块空间,最后这块空间会被析构两次,程序会崩溃。
    所以说,如果是深拷贝的类,即我们要自己实现析构,同时要实现拷贝构造,赋值重载函数时,我们就要自己实现移动构造和移动赋值,如果我们没有实现析构,拷贝构造,赋值中的任意一个,说明我们写的类是浅拷贝的类,这时编译器才会自动给我们生成移动构造和移动赋值,默认生成的移动构造对于内置成员完成值拷贝、浅拷贝,对于自定义类型会看它有没有实现移动构造,有实现就调用移动构造,没有实现就调用拷贝构造。

    如果你提供了移动构造或者移动赋值,编译器就不会自动提供拷贝构造和拷贝赋值。

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

    1.2 类成员变量初始化

    C++11允许在类定义时给成员变量初始缺省值,默认生成构造函数会使用这些缺省值初始化,这个在前面的类和对象的文章中已经谈过了,所以这里就不再重复了。

    1.3 强制生成默认函数的关键字default

    C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数,但是因为一些原因这个函数没有默认生成。比如:我们提供了拷贝构造,就不会生成移动构造了,那么我们可以使用default关键字显式地指定移动构造生成。

    在这里插入图片描述

    1.4 禁止生成默认函数的关键字delete

    如果能想要限制某些默认函数的生成,在C++98中,是该函数设置成private,并且只声明补丁已,这样只要其他人想要调用就会报错。在C++11中更简单,只需在该函数声明加上=delete即可,该语法指示编译器不生成对应函数的默认版本,称=delete修饰的函数为删除函数。

    在这里插入图片描述

    1.5 继承和多态中的final与override关键字

    这个我们在继承和多态的文章中已经进行了详细讲解这里就不再重复谈了。

    二、可变参数模板

    C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板,相比C++98/03,类模版和函数模版中只能含固定数量的模版参数,可变模版参数无疑是一个巨大的改进。

    printf就是一个最常见的带有可变参数列表的函数:
    在这里插入图片描述
    这里要再区分一个概念,模板参数是类型,函数参数是对象。

    下面就是一个基本可变参数的函数模板:
    在这里插入图片描述
    那要如何计算我们传了多少个模板参数呢?
    C++11规定用sizeof就能算出我们传了多少个模板参数了。
    例如:
    在这里插入图片描述上面的参数args前面有省略号,所以它就是一个可变模版参数,我们把带省略号的参数称为“参数包”,它里面包含了0到N(N>=0)个模版参数。我们无法直接获取参数包args中的每个参数的,只能通过展开参数包的方式来获取参数包中的每个参数,这是使用可变模版参数的一个主要特点,也是最大的难点,即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数,所以我们要用一些特别的方式一一获取参数包的值。

    递归函数方式展开参数包
    在这里插入图片描述
    逗号表达式展开参数包
    这种展开参数包的方式,不需要通过递归终止函数,是直接在expand函数体中展开的, printarg不是一个递归终止函数,只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。
    expand函数中的逗号表达式:(printarg(args), 0),也是按照这个执行顺序,先执行printarg(args),再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表,通过初始化列表来初始化一个变长数组, {(printarg(args), 0)…}将会展开成((printarg(arg1),0),(printarg(arg2),0), (printarg(arg3),0), etc… ),最终会创建一个元素值都为0的数组int arr[sizeof…(Args)]。由于是逗号表达式,在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数,也就是说在构造int数组的过程中就将参数包展开了,这个数组的目的纯粹是为了在数组构造的过程展开参数包。
    在这里插入图片描述
    STL容器中的empalce相关接口函数:
    在这里插入图片描述
    首先我们看到的emplace系列的接口,支持模板的可变参数,并且是万能引用。那么相对insert和emplace系列接口的优势到底在哪里呢?
    在这里插入图片描述

    在这里插入图片描述

    三、lambda表达式

    3.1 C++98中的一个例子

    在C++98中,如果想要对一个数据集合中的元素进行排序,可以使用std::sort方法。
    在这里插入图片描述
    如果待排序元素为自定义类型,需要用户定义排序时的比较规则:
    在这里插入图片描述
    随着C++语法的发展,人们开始觉得上面的写法太复杂了,每次为了实现一个algorithm算法,都要重新去写一个类,如果每次比较的逻辑不一样,还要去实现多个类,特别是相同类的命名,
    这些都给编程者带来了极大的不便。因此,在C++11语法中出现了Lambda表达式。

    3.2 lambda表达式

    lambda表达式是一个局部的匿名函数对象。

    struct Goods
    {
    	string _name; // 名字
    	double _price; // 价格
    	int _evaluate; // 评价
    	Goods(const char* str, double price, int evaluate)
    		:_name(str)
    		, _price(price)
    		, _evaluate(evaluate)
    	{}
    };
    int main()
    {
    	vector<Goods> v = { { "雪梨", 2.4, 7 }, { "西瓜", 3.5, 6 }, { "苹果", 2.3,3 }, { "菠萝", 1.6, 4 } };
    
    	//lambda表达式本质是一个局部的匿名函数对象
    	auto ComparePriceLess = [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; };
    	auto ComparePriceGreater = [](const Goods& g1, const Goods& g2) {return g1._price > g2._price; };
    
    	//按价格升序
    	sort(v.begin(), v.end(), ComparePriceLess);
    	for (const auto& e : v)
    	{
    		cout << e._name << "--" << e._price << "--" << e._evaluate << endl;
    	}
    	cout << endl;
    
    	//按价格降序
    	sort(v.begin(), v.end(), ComparePriceGreater);
    	for (const auto& e : v)
    	{
    		cout << e._name << "--" << e._price << "--" << e._evaluate << endl;
    	}
    	cout << endl;
    
    	//按评价升序
    	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate < g2._evaluate; });
    	for (const auto& e : v)
    	{
    		cout << e._name << "--" << e._price << "--" << e._evaluate << endl;
    	}
    	cout << endl;
    
    	//按名字升序
    	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._name < g2._name; });
    	for (const auto& e : v)
    	{
    		cout << e._name << "--" << e._price << "--" << e._evaluate << endl;
    	}
    	cout << endl;
    
    	return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    上述代码就是使用C++11中的lambda表达式来解决,可以看出lambda表达式实际是一个局部的匿名函数对象。

    3.3 lambda表达式语法

    lambda表达式书写格式:[capture-list] (parameters) mutable -> return-type { statement}
    1、lambda表达式各部分说明
    (1)[capture-list] : 捕捉列表,该列表总是出现在lambda函数的开始位置,编译器根据[]来判断接下来的代码是否为lambda函数,捕捉列表能够捕捉上下文中的变量供lambda函数使用。

    (2)(parameters):参数列表。与普通函数的参数列表一致,如果不需要参数传递,则可以连同()一起省略

    (3)mutable:默认情况下,lambda函数总是一个const函数,mutable可以取消其常量性。使用该修饰符时,参数列表不可省略(即使参数为空)。

    (4)->returntype:返回值类型。用追踪返回类型形式声明函数的返回值类型,没有返回值时此部分可省略。返回值类型明确情况下,也可省略,由编译器对返回类型进行推导。

    (5){statement}:函数体。在该函数体内,除了可以使用其参数外,还可以使用所有捕获到的变量。

    注意:
    在lambda函数定义中,参数列表和返回值类型都是可选部分,而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为:[]{}; 该lambda函数不能做任何事情。
    在这里插入图片描述
    通过上述例子可以看出,lambda表达式实际上可以理解为无名函数,该函数无法直接调用,如果想要直接调用,可借助auto将其赋值给一个变量。

    2、捕获列表说明
    捕捉列表描述了上下文中哪些数据可以被lambda使用,以及使用的方式传值还是传引用。
    [var]:表示值传递方式捕捉变量var
    [=]:表示值传递方式捕获所有父作用域中的变量(包括this)
    [&var]:表示引用传递捕捉变量var
    [&]:表示引用传递捕捉所有父作用域中的变量(包括this)
    [this]:表示值传递方式捕捉当前的this指针

    注意:
    a. 父作用域指包含lambda函数的语句块

    b. 语法上捕捉列表可由多个捕捉项组成,并以逗号分割。
    比如:[=, &a, &b]:以引用传递的方式捕捉变量a和b,值传递方式捕捉其他所有变量

    [&,a, this]:值传递方式捕捉变量a和this,引用方式捕捉其他变量

    c. 捕捉列表不允许变量重复传递,否则就会导致编译错误。
    比如:[=, a]:=已经以值传递方式捕捉了所有变量,捕捉a重复

    d. 在块作用域以外的lambda函数捕捉列表必须为空。

    e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量,捕捉任何非此作用域或者非局部变量都会导致编译报错。

    f. lambda表达式之间不能相互赋值,即使看起来类型相同,
    但是在底层的类型是不同的。

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

    3.4 函数对象与lambda表达式

    函数对象,又称为仿函数,即可以想函数一样使用的对象,就是在类中重载了operator()运算符的类对象。例如:

    class Rate
    {
    public:
    	Rate(double rate) : _rate(rate)
    	{}
    
    	double operator()(double money, int year)
    	{
    		return money * _rate * year;
    	}
    
    private:
    	double _rate;
    };
    
    int main()
    {
    	// 函数对象
    	double rate = 0.56;
    	Rate r1(rate);
    	r1(5000, 10);
    
    	// lambda
    	auto r2 = [=](double monty, int year)->double {return monty * rate * year; };
    	r2(5000, 10);
    
    	return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    从使用方式上来看,函数对象与lambda表达式完全一样。
    函数对象将rate作为其成员变量,在定义对象时给出初始值即可,lambda表达式通过捕获列表可以直接将该变量捕获到。
    在这里插入图片描述
    通过上图可知,实际在底层编译器对于lambda表达式的处理方式,完全就是按照函数对象的方式处理的,即:如果定义了一个lambda表达式,编译器会自动生成一个类,在该类中重载了operator()。所以lambda表达式在底层也是一个仿函数。

    常见的可调用对象有三个:
    函数指针,仿函数对象,lambda表达式。

    四、包装器

    4.1 function包装器

    function包装器,也叫作适配器。C++中的function本质是一个类模板,也是一个包装器。

    //ret = func(x);
    //上面func可能是什么呢?func是一个可调用对象,所以func可能是函数指针,函数对象(仿函数对象),
    //也有可能是lamber表达式对象,如此丰富的类型,可能会导致模板的效率低下!为什么呢?我们继续往下看
    template<class F, class T>
    T useF(F f, T x)
    {
    	static int count = 0;
    	cout << "count:" << ++count << endl;
    	cout << "count:" << &count << endl;
    
    	return f(x);
    }
    
    //函数指针
    double f(double i)
    {
    	return i / 2;
    }
    
    //仿函数类
    struct Functor
    {
    	double operator()(double d)
    	{
    		return d / 3;
    	}
    };
    
    int main()
    {
    	// 函数名,即函数指针
    	cout << useF(f, 11.11) << endl;
    	// 仿函数类对象
    	cout << useF(Functor(), 11.11) << endl;
    	// lamber表达式
    	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
    
    	return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    通过上面的程序验证,我们会发现useF函数模板实例化了三份。
    有了包装器就可以很好地解决上面的问题。

    template<class F, class T>
    T useF(F f, T x)
    {
    	static int count = 0;
    	cout << "count:" << ++count << endl;
    	cout << "count:" << &count << endl;
    
    	return f(x);
    }
    
    //函数指针
    double f(double i)
    {
    	return i / 2;
    }
    
    //仿函数类
    struct Functor
    {
    	double operator()(double d)
    	{
    		return d / 3;
    	}
    };
    
    int main()
    {
    	 函数名,即函数指针
    	//cout << useF(f, 11.11) << endl;
    	 仿函数类对象
    	//cout << useF(Functor(), 11.11) << endl;
    	 lamber表达式
    	//cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
    
    	//包装器本质是一个适配器,可以封装像函数指针,仿函数,lambda表达式这样的可调用对象
    	vector<function<double(double)>> f1 = { f ,[](double x) {return x / 4; },Functor() };
    	int n = 10;
    	for (const auto& func : f1)
    	{
    		cout << func(n++) << endl;
    	}
    
    
    	return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    //函数指针
    int f(int a, int b)
    {
    	return a + b;
    }
    
    //仿函数
    struct Functor
    {
    public:
    	int operator() (int a, int b)
    	{
    		return a + b;
    	}
    };
    
    class Plus
    {
    public:
    	static int plusi(int a, int b)
    	{
    		return a + b;
    	}
    	double plusd(double a, double b)
    	{
    		return a + b;
    	}
    };
    
    int main()
    {
    	// 函数名(函数指针)
    	std::function<int(int, int)> func1 = f;
    	cout << func1(1, 2) << endl;
    
    	// 函数对象(仿函数)
    	std::function<int(int, int)> func2 = Functor();
    	cout << func2(1, 2) << endl;
    
    	// lambda表达式
    	std::function<int(int, int)> func3 = [](const int a, const int b){return a + b; };
    	cout << func3(1, 2) << endl;
    
    	// 类的成员函数
    	//类的静态成员,&符号可写可不写,但是建议写上
    	//std::function func4 = Plus::plusi;
    	std::function<int(int, int)> func4 = &Plus::plusi;
    	cout << func4(1, 2) << endl;
    	//非静态成员,必须要带上&符号
    	std::function<double(Plus, double, double)> func5 = &Plus::plusd;
    	cout << func5(Plus(), 1.1, 2.2) << endl;
    
    	return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54

    有了包装器,如何解决模板的效率低下,实例化多份的问题呢?

    template<class F, class T>
    T useF(F f, T x)
    {
    	static int count = 0;
    	cout << "count:" << ++count << endl;
    	cout << "count:" << &count << endl;
    	return f(x);
    }
    double f(double i)
    {
    	return i / 2;
    }
    struct Functor
    {
    	double operator()(double d)
    	{
    		return d / 3;
    	}
    };
    int main()
    {
    	// 函数名
    	std::function<double(double)> func1 = f;
    	cout << useF(func1, 11.11) << endl;
    	// 函数对象
    	std::function<double(double)> func2 = Functor();
    	cout << useF(func2, 11.11) << endl;
    	// lamber表达式
    	std::function<double(double)> func3 = [](double d)->double { return d / 4; };
    	cout << useF(func3, 11.11) << endl;
    
    	//函数指针,仿函数,lambda表达式经过包装器包装之后都会变成同一个类型了
    	//所以使用useF时传func1,func2和func3都是同一个类型了,即模板只会实例化
    	//出一份代码
    
    	return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    在这里插入图片描述

    4.2 bind

    std::bind函数定义在头文件中,是一个函数模板,它就像一个函数包装器(适配器),接受一个可调用对象(callable object),生成一个新的可调用对象来“适应”原对象的参数列表。一般而言,我们用它可以把一个原本接收N个参数的函数fn,通过绑定一些参数,返回一个接收M个(M可以大于N,但这么做没什么意义)参数的新函数。同时,使用std::bind函数还可以实现参数顺
    序调整等操作。
    在这里插入图片描述
    可以将bind函数看作是一个通用的函数适配器,它接受一个可调用对象,生成一个新的可调用对象来“适应”原对象的参数列表。
    在这里插入图片描述

    // 使用举例
    #include 
    int add(int a, int b)
    {
    	return a + b;
    }
    class Sub
    {
    public:
    	int sub(int a, int b)
    	{
    		return a - b;
    	}
    
    	static int ssub(int a, int b)
    	{
    		return a - b;
    	}
    };
    int main()
    {
    	//表示绑定函数add 参数分别由调用 func1 的第一,二个参数指定
    	function<int(int, int)> func1 = bind(add, placeholders::_1, placeholders::_2);
    	//auto func1 = bind(add, placeholders::_1, placeholders::_2);
    	
    	//func2的类型为 function 与func1类型一样
    	//表示绑定函数 add 的第一,二为: 1, 2
    	auto func2 = bind(add, 1, 2);
    	cout << func1(1, 2) << endl;
    	cout << func2() << endl;
    
    
    	Sub s;
    	//对于非静态的成员函数,第一个参数必须写成&Sub::ssub;但是对于静态的成员函数,第一个参数可以写成
    	// &Sub::ssub,也可以写成Sub::ssub,建议统一写上&符号
    	//s参数可以&,也可以不&;因为我们传&s时,编译器会类似于用对象的指针->访问,如果传的参数是s,就是对象.访问一样
    	function<int(int, int)> func = bind(Sub::ssub, placeholders::_1, placeholders::_2);
    	//function func = bind(&Sub::ssub, placeholders::_1, placeholders::_2);
    	function<int(int, int)> func3 = bind(&Sub::sub, s,placeholders::_1, placeholders::_2);
    	//function func3 = bind(&Sub::sub, &s, placeholders::_1, placeholders::_2);
    	cout << func3(1, 2) << endl;
    
    	// 参数调换顺序
    	function<int(int, int)> func4 = bind(&Sub::sub, s,placeholders::_2, placeholders::_1);
    	//function func4 = bind(&Sub::sub, &s, placeholders::_2, placeholders::_1);
    	cout << func4(1, 2) << endl;
    
    	return 0;
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    以上就是今天想要跟大家分享的内容,你学会了吗?如果感觉到有所收获,那就点点小心心,点点关注呗!后期还会持续更新C++的相关知识哦,我们下期见!!!

  • 相关阅读:
    Hi5 2.0 产品说明书-Ver 1.0
    渲染如何做到超强渲染?MAX插件CG MAGIC中的渲染功能!
    机器学习基础入门(二)(线性回归与成本函数)
    AJAX and Javaweb
    ARM按键中断实验
    【编程题】【Scratch二级】2021.03 两座对称的山峰
    requests.sessions.Session() 和 requests.Session()是相同的
    android Binder安全性、Unix Socket安全性研究
    事务隔离级别和MVCC
    音频转文字怎么操作?推荐三个实用软件
  • 原文地址:https://blog.csdn.net/weixin_70056514/article/details/133375924