【C++】C++11常见特性

最新推荐文章于 2024-11-08 23:39:16 发布
最新推荐文章于 2024-11-08 23:39:16 发布
阅读量304 收藏 24
点赞数 33
分类专栏： C++修炼内功 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vhhhbb/article/details/134148187
版权

🌇个人主页：平凡的小苏
📚学习格言：命运给你一个低的起点，是想看你精彩的翻盘，而不是让你自甘堕落，脚下的路虽然难走，但我还能走，比起向阳而生，我更想尝试逆风翻盘。
🛸C++专栏：C++内功修炼基地
> 家人们更新不易，你们的👍点赞👍和⭐关注⭐真的对我真重要，各位路 过的友友麻烦多多点赞关注。 欢迎你们的私信提问，感谢你们的转发！ 关注我，关注我，关注我，你们将会看到更多的优质内容！！

在这里插入图片描述

一、c++11介绍

C++98 / 03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98 / 03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习。

二、列表初始化

在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。

示例:

struct A
{
	int _x;
	int _y;
};
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5 };
	int arr2[5] = { 0 };
	A a = { 1, 2 };
	return 0;
}

C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

示例：

struct A
{
	int _x;
	int _y;
};
int main()
{
	int n1 = 1;
	int n2{ 2 };
	int arr1[]{ 1, 2, 3, 4, 5 };
	int arr2[5]{ 0 };
	A a{ 1, 2 };
	// C++11中列表初始化也可以适用于new表达式中
	int* pa = new int[4]{ 0 };
	return 0;
}

创建对象时也可以使用列表初始化方式调用构造函数初始化

class Date
{
    public:
    Date(int year, int month, int day)
        :_year(year)
            ,_month(month)
            ,_day(day)
        {
            cout << "Date(int year, int month, int day)" << endl;
        }
    private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1(2022, 1, 1); // old style
    // C++11支持的列表初始化，这里会调用构造函数初始化
    Date d2{ 2022, 1, 2 };
    Date d3 = { 2022, 1, 3 };
    return 0;
}

2.1、initializer_list

initializer_list使用场景:

std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值。

示例：

int main()
{
    vector<int> v = { 1,2,3,4 };
    list<int> lt = { 1,2 };
    // 这里{"sort", "排序"}会先初始化构造一个pair对象
    map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
    // 使用大括号对容器赋值
    v = {10, 20, 30};
    return 0;
}

三、声明类型

3.1、auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

在这里插入图片描述

3.2、decltype

关键字decltype将变量的类型声明为表达式指定的类型。

// decltype的一些使用使用场景
template<class T1, class T2>
    void F(T1 t1, T2 t2)
{
    decltype(t1 * t2) ret;
    cout << typeid(ret).name() << endl;
}
int main()
{
    const int x = 1;
    double y = 2.2;
    decltype(x * y) ret; // ret的类型是double
    decltype(&x) p;      // p的类型是int*
    cout << typeid(ret).name() << endl;
    cout << typeid(p).name() << endl;
    F(1, 'a');
    return 0;
}

在这里插入图片描述

四、右值引用和移动语义

4.1、新增的两个默认成员函数

C++11新增了两个类的默认成员函数：移动构造函数和移动赋值运算符重载。

如果你没有手动实现移动构造函数，并且析构函数、拷贝构造、赋值运算符重载均没有手动实现，编译器就会帮你生成一个默认的移动构造函数。默认生成的移动构造函数，对于内置类型进行按字节的值拷贝，对于自定义类型，将会去调用它的移动构造函数，如果这个内置类型并没有移动构造函数，则编译器去调用它的拷贝构造函数。

如果你没有手动实现移动赋值运算符重载，并且析构函数、拷贝构造、赋值运算符重载均没有手动实现，编译器就会帮你生成一个默认的移动赋值运算符重载。默认生成的移动赋值运算符重载，对于内置类型进行按字节的值拷贝，对于自定义类型，将会去调用它的移动赋值运算符重载，如果这个内置类型并没有移动赋值运算符重载，则编译器去调用它的赋值运算符重载。

4.2、强制与禁止生成默认成员函数的关键字

1、default

Person(Person&& p)=default;//让编译器强制生成移动构造

Person(Person&& p)=default;//让编译器强制生成移动构造

2、delete

例如现在需要禁用某个类的拷贝构造函数，C++98的玩法是将这个类的拷贝构造函数加上私有权限，并且只声明不实现，就可以在类的内部和外部禁用掉拷贝构造。

C++11使用delete关键字禁止生成某个默认构造函数：

A(const A& a)=delete;//防拷贝

4.3、左值和右值

1、左值和左值引用

变量和解引用得到的变量是左值，我们可以获取它的地址，左值可以出现赋值符号的左边和右边，右值只能出现在赋值符号的右边。

int main()
{
    // 以下的a、k、c、*p都是左值
    int* a = new int(0);
    int k = 1;
    const int c = 2;
    // 以下几个是对上面左值的左值引用
    int*& tp = a;
    int& tb = k;
    const int& rc = c;
    int& p_val = *a;
    return 0;
}

2、右值和右值引用

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。C++11中将右值划分成纯右值（内置类型表达式的值）和将亡值（自定义类型的表达式的值）

int main()
{
    double x = 1.1, y = 2.2;
    // 以下几个都是常见的右值
    10;
    x + y;
    fmin(x, y);
    // 以下几个都是对右值的右值引用
    int&& rr1 = 10;
    double&& rr2 = x + y;
    double&& rr3 = fmin(x, y);
    // 这里编译会报错：error C2106: “=”: 左操作数必须为左值
    10 = 1;
    x + y = 1;
    fmin(x, y) = 1;
    return 0;
}

总结：

  1. 右值引用只能引用右值，不能引用左值。

  2. 但是右值引用可以引用move以后的左值。

int main()
{
     // 右值引用只能右值，不能引用左值。
     int&& r1 = 10;
     
     // error C2440: “初始化”: 无法从“int”转换为“int &&”
     // message : 无法将左值绑定到右值引用
     int a = 10;
     int&& r2 = a;
     // 右值引用可以引用move以后的左值
     int&& r3 = std::move(a);
     return 0;
}

4.4、右值的别名是左值

右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1，这里的rr1是左值。如果不想rr1被修改，可以用const int&& rr1 去引用。（这个特性在移动赋值中也可以体现，移动赋值参数是右值引用，通过交换这个右值引用的对象完成赋值的目的）

int main()
{
     double x = 1.1, y = 2.2;
     int&& rr1 = 10;//rr1其实是一个左值
     const double&& rr2 = x + y;
     rr1 = 20;
     rr2 = 5.5;//报错  
     return 0;
}

因为右值引用的形参是左值，层层传递时，需要将这个形参move为右值：

void push_back(T&& x)//x为左值
{
	insert(end(),move(x));//需要用move转换为右值，不然会去调用左值版本的insert
}    
iterator insert(interator pos,T&& x)//x为左值
{
	node* newnode=new node(move(x));//需要用move转换为右值，不然会去调用左值版本的node构造函数
}
list_node(T&& x)//x是左值
	：_next(nullptr)
    ,_prev(nullptr)
    ,_data(move(x))//需要用move转换为右值，不然会去调用左值版本的T _data的构造函数
{}

不过这样写的话需要左值写一份，右值的写一份，代码重复了。更推荐下面讲的完美转发的写法。

4.5、模板中的万能引用

#include <iostream>

using namespace std;
// decltype的一些使用使用场景
void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}
int main()
{
	PerfectForward(10);// 右值
	int a;
	PerfectForward(a);// 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b);// const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}
  • 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
  • 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发

在这里插入图片描述

注意：这里不使用完美转发都是左值引用，下面看使用完美转发

4.6、完美转发

std::forward 完美转发在传参的过程中保留对象原生类型属性，当然完美转发也是需要在模板的环境下才能生效，如果不是模板，T&& t同样会被识别成右值引用。

万能引用和完美转发必须保证传参时，才实例化对象，如果传参前模板已经被实例化了，将构不成万能引用和完美转发。

在这里插入图片描述

4.7左值引用和右值引用使用场景

左值引用使用场景

左值引用在函数传参、函数传返回值（必须保证返回值出了作用域还在）时使用可以减少拷贝。如果函数的返回值出了作用域会被销毁，则不能使用左值引用来减少拷贝（销毁后引用的对象非法），这个时候就需要使用右值引用了。C++在没有右值引用的时候，可以采用输出型参数的方法解决传值返回多次拷贝的问题。

右值引用场景

使用场景一：深拷贝的类中的传值返回的拷贝问题

C++11通过右值引用实现的移动构造和移动赋值解决值返回多次拷贝的问题，提升了效率：

class string
{
public:
    //拷贝构造
    string(const string& s)//传入的s是左值，需要老老实实构造
    {
        string tmp(s.c_str());
        swap(tmp);
    }
    //移动构造
    string(string&& s)//传入的s是将亡值，可以换走s的成员
    {
        swap(s);//将s的成员直接换给*this，s消亡后自动调用析构函数
    }
	// 赋值重载
    string& operator=(const string& s)
    {
        string tmp(s);
        swap(tmp);
        return *this;
    }
	// 移动赋值
    string& operator=(string&& s)
    {
        swap(s);
        return *this;
    }
private:
    char* _str = nullptr;
    size_t _capacity = 0;
    size_t _size = 0;
};

对于深拷贝的类，C++11使用右值引用实现的移动构造和移动赋值，在需要拷贝的场景中，可以直接转移将亡值的资源。如下图，虽然to_string是传值返回，但是str被编译器识别为将亡值，编译器会调用移动构造一步到位的对ret1进行构造，代价很低。
在这里插入图片描述

使用场景二：插入右值数据，也可以减少拷贝

int main()
{
	list<string> it;
	string s1("1111");
	it.push_back(s1);//左值，深拷贝
	it.push_back(string("2222"));//右值，直接移动构造转移右值资源
	it.push_back("3333");//右值，直接移动构造转移右值资源
	return 0;
}

五、lamaba表达式

5.1、lamaba表达式介绍

lambda表达式的作用是创建一个匿名函数，可以在需要函数对象的地方使用。它通常用于函数式编程中，可以避免定义一个命名函数，从而简化代码。使用lambda表达式可以在代码中直接定义一个函数对象，并将其作为参数传递给其他函数或算法，或者直接调用它。lambda表达式可以捕获其所在作用域的变量，并将其作为函数对象的成员变量，从而实现闭包功能。使用lambda表达式可以使代码更加简洁、清晰，提高程序的可读性和可维护性。

//lambda本质是一个匿名函数，其表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }

  • [capture - list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用，必须写；

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

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

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

  • {
    statement
    }：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，必须写。使用lamaba表达式进行排序

在这里插入图片描述

5.2、lamaba表达式的捕捉列表、mutable

这是一段lambda表达式对外部参数b的捕获：

int main()
{
	int a = 0, b = 1;
	auto add = [b](int a) {return a + b; };//把上文的b捕捉到lambda表达式中
	return 0;
}

捕捉的真的是b吗？其实捕捉的仅仅是带const属性的b的拷贝罢了。可使用mutable取消拷贝对象的const属性：

auto add = [b](int a) mutable{return a + b; };//取消b的const属性

现在我想用lambda表达式交换一下外部两个变量的值，那么就需要在捕捉列表中引用这两个变量：

int main()
{
	int a = 0, b = 1;
	auto swap = [&a, &b]()//这里是引用的方式捕捉，不是取地址
	{
		int tmp = a;
		a = b;
		b = tmp;
	};
	swap();
	std::cout << a << " " << b << std::endl;
	return 0;
}

上面的lambda表达式的捕捉列表中的&a和&b其实是a和b的引用，不要理解成取地址。因为捕捉只有两种方式：传值捕捉和传引用捕捉。静态变量和全局变量无法捕捉，但可以在lambda表达式中直接使用并自带引用属性。

5.3、捕获列表说明

捕捉列表描述了上下文中那些数据可以被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表达式之间不能相互赋值，即使看起来类型相同

5.4、lambda的底层就是仿函数

在这里插入图片描述

六、容器中新增的emplace系列

6.1、可变参数模板

c++11的新增特性可变参数模板能够让使用者创建可以接受可变参数的函数模板和类模板。

下面就是一个基本可变参数的函数模板

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些奇招来一一获取参数包的值。

// 递归终止函数
void ShowList()
{
	cout << endl;
}

template<class T, class ...Args>
void ShowList(T value, Args ...args)//语法规定在template中，三个点在args的前面
{
	cout << value << " ";
	ShowList(args...);//语法规定，传参时三个点在args的后面
}
int main()
{
	ShowList();
	ShowList(1);
	ShowList(1,std::string("left"));
	return 0;
}

解析：

  • ShowList(1,’A’,std::string(“left”))进行调用

  • 首次将调用模板函数ShowList，

  • val是1，参数包还剩下一个参数string(“left”)

  • 函数内部调用ShowList，并传递参数包

  • 再次调用模板函数ShowList

  • val是string(“left”)，并传递参数包

  • 根据匹配规则，将调用无参的函数ShowList

  • 流程结束

方式二:逗号表达式展开参数包(方式不能解析0个参数的参数包)

这种展开参数包的方式，不需要通过递归终止函数，是直接在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数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包.

template <class T>
int PrintArgs(T t)
{
	std::cout << t << " ";
	return 0;
}
template <class ...Args>
void ShowList(Args... args)
{
	//int arr[] = { (PrintArgs(args),0)... };//逗号表达式
    //参数包有几个值，数组就开多大，函数就被调用几次，函数调用时依次展开参数包中内容
	int arr[] = { PrintArgs(args)... };
	std::cout << std::endl;
}
int main()
{
	//ShowList();
	ShowList(1);
	ShowList(1,std::string("xxxxx"));
	return 0;
}

6.2、emplace系列的优势

int main()
{
	std::list<int> list1;
	list1.push_back(1);
	list1.emplace_back(2);
	list1.emplace_back();//会插入0
    
	std::list< std::pair<int, char> > mylist;
	mylist.push_back(make_pair(1, 'a'));  // 构造+拷贝构造（如果是右值就是构造+移动构造）
	//mylist.push_back(1, 'a');//push_back不允许传两个参数
    mylist.push_back({ 40, "sort" });//列表初始化
	mylist.emplace_back(1, 'a'); // empalce支持多参数，直接构造
	return 0;
}

int main()
{
	pair<int, std::string> kv(20, "sort");
	std::list< std::pair<int, std::string> > mylist;
 
	mylist.push_back(kv); // 左值
	mylist.push_back(make_pair(30, "sort")); // 右值
	mylist.push_back({ 40, "sort" }); // 右值
 
    mylist.emplace_back(kv); // 左值
	mylist.emplace_back(make_pair(20, "sort")); // 右值（简化为一次构造）
	mylist.emplace_back(10, "sort"); // 构造pair参数包（简化为一次构造）
 
	return 0;
}

无论是push_back还是emplace_back,尽量不要使用左值进行插入操作，插入左值必发生拷贝构造。

push_back方法：
对于非深拷贝类型，push_back会调用构造+拷贝构造，如果元素是深拷贝的对象，就是构造+移动构造。

emplace_back方法：
emplace_back方法会在容器尾部直接构造一个新元素，它的参数是元素的构造函数参数列表。emplace系列能将参数包展开，将过程简化为一次构造。

所以从效率上来说，emplace系列会高效一点.如果一个深拷贝的类没有实现移动构造，这个时候push_back的效率将远不如emplace_back。

七、包装器

1、function包装器

1.1、包装器的意义

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

function的作用是对各种可调用对象进行类型统一。

在这里插入图片描述

函数模板Use被实例化了三份，使用包装器可以解决这一问题。

在这里插入图片描述

1.2、包装器的使用

在这里插入图片描述

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()
{
	// 函数名(函数指针)的三种写法
	function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;
 
	function<int(int, int)> func2;
	func2 = f;
	cout << func2(1, 2) << endl;
 
	function<int(int, int)> func3(f);
	cout << func3(1, 2) << endl;
	// 函数对象
	function<int(int, int)> func4 = Functor();
	cout << func4(1, 2) << endl;
	// lamber表达式
	function<int(int, int)> func5 = [](const int a, const int b)
	{return a + b; };
	cout << func5(1, 2) << endl;
 
	// 类的成员函数，包装器的静态成员函数可以不加&取地址，普通函数需要加&取地址，建议一律加上
	function<int(int, int)> func6 = &Plus::plusi;//类静态成员函数指针，&可加可不加
	cout << func6(1, 2) << endl;
	function<double(Plus, double, double)> func7 = &Plus::plusd;//类成员函数指针，&必须加，并且需要传类名
	cout << func7(Plus(), 1.1, 2.2) << endl;//调用的时候得传对象，不是传&Plus的地址
	//function包装带捕获的lambda表达式
	Plus plus;
	function<double(double, double)> func8 = [&plus](double x, double y)->double {return plus.plusd(x, y); };
	cout << func8(1.1, 2.2) << endl;
	return 0;
}

2.bind

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。可以用于固定绑定参数和调整参数的顺序。

// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2) 
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);

#include <iostream>
#include<map>
#include<functional>
using namespace std;

int Plus(int a, int b)
{
	return a + b;
}
int SubFunc(int a, int b)
{
	return a - b;
}
class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	//表示绑定函数Plus 参数分别由调用 func1 的第一，二个参数指定
	::function<int(int, int)> func1 = ::bind(Plus, placeholders::_1,placeholders::_2);
	cout << func1(1, 2) << endl;
	function<int(int, int)> func2 = bind(SubFunc, placeholders::_1, placeholders::_2);
	cout << func2(1, 2) << endl;
	//调整参数的顺序
	function<int(int, int)> func3 = bind(SubFunc, placeholders::_2, placeholders::_1);
	cout << func3(1, 2) << endl;
	function<bool(int, int)> gt = bind( less<int>(), placeholders::_2, placeholders::_1);//降序
	cout << gt(1, 2) << endl;
	//固定绑定参数
	function<int(Sub, int, int)> func4 = &Sub::sub;
	cout << func4(Sub(),1, 2) << endl;//这样写总是要传入一个类匿名对象进行打印
	function<int(int, int)> func5 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);//固定sub()
	cout << func5(1, 2) << endl; 
	return 0;
}
平凡的小苏
关注
专栏目录
c++11特性（详细）
lim6ere的博客
05-29 1884
在本篇文章，我们将会详细介绍一下C++11新增的一些特性，其中最重要的是右值引用，智能指针等，这其中也产生了很多不必要的语法设计。在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。
C++11——新特性超详细总结
m0_65635427的博客
07-03 3033
18. 负浮点数：^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$17. 正浮点数：^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
C++11特性（详细版）
weixin_46873777的博客
03-17 2万+
C111、C11优势2、列表初始化3、变量类型推导1、为什么需要类型推导2、decltype类型推导（了解）为什么需要decltypedecltype4、final 与 overridefinaloverride5、默认成员函数控制1、显示缺省函数2、删除默认函数（禁止调用）6、右值引用与移动语义1、左值引用和右值引用1、什么是左值？什么是左值引用？2、什么是右值？什么是右值引用？2、左值引用与右值引用比较3、右值引用使用场景和意义7、完美转发8、新的类功能 1、C11优势   相比C++98/03，C++
c++面试之c++11新特性
weixin_45249333的博客
04-22 1308
c++面试之c++11新特性，智能指针，移动语义和完美转发，lambda表达式，final和overide关键字，左值右值，auto和decltype关键字,default关键字，const和constexpr关键字
C++11-C++17新特性介绍
Computer_Tech的博客
12-22 1897
本篇只包含c++11- c++17的新特性, 一些c++基本规定不再赘述前文c++规定记录了c++基本规定对于这些新特性,笔者一边学习一边做笔记,所以内容有待完善笔者使用的是 Clion+MinGW 开发环境提示：以下是本篇文章正文内容，下面案例可供参考using 覆盖了 typedef 的全部功能// 重定义unsigned int// 重定义std::map//定义函数类型和模板的结合使用// ...别名模板（alias template）
C++11新特性
冯同学的博客
07-02 5541
C++11新特性
C++11 常用的新特性
Bobowen的博客
01-31 2941
本篇介绍C++11标准对比之前C++标准的新特性，C++11为C++语言在2011年发布的版本，它改进幅度很大，影响至今。如加入auto 关键字、nullptr、移动语义（move semantics）、委托构造函数（delegating constructors）、默认构造函数（default constructor）、类型别名（type alias）、右值引用（rvalue reference）、Lambda 表达式（lambda expressions）、静态断言等。
C++11新特性详解
AI_ELF的博客
07-23 9058
相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率。在C++11之前，涉及到多线程问题，都是和平台相关的，比如windows和linux下各有自己的接口，这使得代码的可移植性比较差。thread在线文档说明stdreturn0。...
C++版本发展简史：新特性介绍
欧特GO
06-07 1万+
C++版本发展简史：新特性介绍
【C++11】新特性
Cayyyy的博客
10-06 1567
C++11
引发C++软件异常的常见原因分析与总结（实战经验分享）
热门推荐
dvlinker的技术专栏
05-30 5万+
本文根据近几年排查C++软件异常的实践经历与实战经验，详细地总结出引发C++软件异常的常见原因，给大家提供一些借鉴和参考，以帮助大家快速地定位问题。
C++ 新特性 | C++14 常用新特性介绍
dvlinker的技术专栏
08-09 6794
本文详细介绍一下C++14的常用新特性。
C++ 新特性 | C++20 常用新特性介绍
dvlinker的技术专栏
08-09 5538
本文详细介绍C++20的常用新特性。
C++11 新特性 ① | C++11 常用关键字实战详解
dvlinker的技术专栏
09-05 2万+
本文结合工作实践详细介绍C++11 常用关键字，以供借鉴或参考。
排查C++软件异常的常见思路与方法（实战经验总结）
dvlinker的技术专栏
10-06 5万+
在多年排查C++软件异常实践的基础上，系统地总结了排查C++软件异常的常见思路与方法，有很强的实战参考价值！
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 656
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 77
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
最新发布
caridle的专栏
11-08 364
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 19
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
C++11新特性详解与FAQ
"C++11FAQ中文版" 是一份167页的PDF文档，包含了C++11标准的常见问题解答，旨在帮助学习者理解C++11新引入的各种特性和更新。文档包含了C++之父Bjarne Stroustrup的授权许可以及他对C++11的一些说明。这份FAQ涵盖了...
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

平凡的小苏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值