了解c++11中的新增

一，统一的初始化列表

在引入c++11后，我们得出计划都可以用初始化列表进行初始化。

int  main()
{
	int i = 0;
	int j = { 0 };
	int k{ 0 };
	int l(0);
	//如日期类
	
	return 0;
}

//对象的初始化
struct Point
	{
		int _x;
		int _y;
	};
	
int main()
	{
		int array1[] = { 1, 2, 3, 4, 5 };
		int array2[5] = { 0 };
		Point p = { 1, 2 };
		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 };
	//这里的本质就是，以该参数构造对象再拷贝给给这里的对象
	Date* d4 = new Date[3]{ {2023,5,3}, {2022, 1, 3},{2023,1,2} };
	return 0;
}

数组与链表的初始化

int main()
{
	vector<int> v = { 1,2,3,4,5,6 };
	list<string> l = { "hello","world" };
	return 0;
}

并且再c++11引入了std::initializer_list ，一种特殊的构造方式：

initiallizer_list

initializer_list是C++11提供的新类型，定义在头文件中。 用于表示某种特定类型的值的数组，和vector一样，initializer_list也是一种模板类型。即一组数据的类型。

一般它的作用也就是为了支持容器的参数列表的构造。

如下：通过typeid我们来查看il的类型，

库中的定义： 

 

 库中实现了三个成员函数，分别是首尾和大小。我们不难看出这肯定是实现了迭代器，也确实是这样样，他的迭代器就是他的原生指针。

int main()
{
	auto il = { 1,2,3,4,5 };
	cout << typeid(il).name()<<endl;
	auto it = il.begin();
	while (it != il.end())
	{
		cout << *it;
		it++;
	}
	cout << endl;
	for (auto it : il)
	{
		cout << it;
	}
	return 0;
}

 对于initailizer_list,不仅仅是一般的类型的数据的和，对于vector,list,map,set等构造都支持参数列表（nitailizer_list）这样的初始化：

int main()
{
	pair<string, string> kv = { "希尔排序","1" };
	map<string, string> p = { kv,{"冒泡排序","2"},{"快速排序","3"}};
	//初始化map时，除了用pair，我们这里也可以用initializer_list  ->实际上回隐式类型转换为pair
	for(auto &it:p)
	{
		cout << it.first<<" "<<it.second<< endl;
	}
	return 0;
}

 二，声明

auto

自动类型推导，更加简便的声明。实际当中，我们一般范围for用，

decltype

首先ret在这里会调用三次深拷贝，代价太大，那么有无优化的方案？

 对于这里的ret，还是传值返回，但是在即将销毁时，我们可以将它识别是一个将亡值（右值），对于将亡值，我们拷贝构造时，使用右值引用传参（移动拷贝），直接把资源转移过来，不再进行深度拷贝，但是在进入main函数中的拷贝之后，赋值是不支持右值对象的，因此这里还需要实现右值赋值。

amespace myspace
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		string tostring(int x)
		{
			string ret;
			while (x)
			{
				int val = x % 10;
				x = x / 10;
				ret += (val + '0');
			}
			return ret;
		}
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;
			string tmp(s._str);
			swap(tmp);
		}
		// 赋值重载
		string& operator=(const string& s)
		{
				cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}
		// 移动构造  右值引用
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移动语义" << endl;
			swap(s);
		}
		// 移动赋值  右值引用
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动语义" << endl;
			swap(s);
			return *this;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}
				_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}

通过右值引用我们减掉了深度拷贝的代价。这里我们一般还可以通过调试查看函数调用信息，

对于将亡值，我们一般使用move将一个左值转化为将亡值。自定义的右值一般也是将亡值。

仔细看的话，用过右值引用，我们还将他的生命周期延长了，我们通过右值引用使得这份资源还在。

当然我这里的右值引用，移动构造对于深拷贝就能发挥它的作用，浅拷贝的自定义类型没什么用。

注意：注意move移动语义，本是是不会改变这个值的属性，而是调用后的返回值的类型发生了改变。

其次对于一个右值的引用之后它的属性是一个左值，因为右值不能被修改，但是右值的右值引用可以被修改，否则无法实现移动构造，与移动复制。

库中的一些应用

 除了返回值可以被引用外，移动构造与移动拷贝相对于左值的拷贝构造，赋值。更加的快速和节省空间，因为我们这里直接是引用。

通过右值引用实现了返回值的引用，以这种方式许多场景下的应用就可以实现了。

c+11后，我们通过转化为右值，使用移动构造，移动拷贝，效率就会高许多。

STL容器在c++11后，都增加了移动构造与移动赋值。

vector的构造与赋值

 

list的构造与赋值

以及push操作也基本添加了右值版本：

万能引用

c++11在提供右值及右值引用后，还增加了万能引用。

所谓的万能引用，就是模板参数的引用，这里用的是&&，但不代表是右值引用。

格式如下：

template<typename T>
void PerfectForward(T&& t)
{
 Fun(t);
}

通过万能引用，是左值就调左值引用，是右值就调右值引用。但是还是要记住一点，右值被右值引用之后，属性是左值，因此在处理右值传参用右值对应的接口，我们都需要吧接口里的值的类型在move一下。

注意事项：

针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任

意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类

型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，

如果实现了就调用移动构造，没有实现就调用拷贝构造。

如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中

的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内

置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋

值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。 ( 默认移动赋值跟上面移动构造

完全类似 )

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

七.defalut与delete

八，模板的可变参数

首先我们知道函数的参数可以是可变参数，c++11对模板也引入了可变参数。

这里的参数，我们叫可变参数包，

template<class ...Args> //模板的可变参数包
void show(Args...arg)
{
	//可以包含任意多个类型的参数
}

九，lambda表达式

在c++98之前，比如我们在用sort进行排序时，我们是传一个仿函数，且该种排序只能支持库里提供的类型，另外的类型就需要我们重写一个仿函数传进去。

操了c++11,虽然问题得到了解决，但是人们认为这样写还是太过麻烦，比如每次传参进去的仿函数都必须以它如何排序的方式进行命名，因为具体实现的比较我们是看不到的，因此借鉴了python的lambda表达式，实现更加方便，更加清晰的比较。

lambda表达式的构成：

lambda 表达式书写格式： [capture-list] (parameters) mutable -> return-type { statement

}

lambda 表达式各部分说明：

[capture-list] : 捕捉列表 ，该列表总是出现在 lambda 函数的开始位置， 编译器根据 [] 来

判断接下来的代码是否为 lambda 函数 ， 捕捉列表能够捕捉上下文中的变量供 lambda

函数使用 。

(parameters) ：参数列表。与 普通函数的参数列表一致 ，如果不需要参数传递，则可以

连同 () 一起省略。

mutable ：默认情况下， lambda 函数总是一个 const 函数， mutable 可以取消其常量

性。使用该修饰符时，参数列表不可省略 ( 即使参数为空 ) 。---不需要一般可以忽略不写

->returntype ：返回值类型 。用 追踪返回类型形式声明函数的返回值类型 ，没有返回

值时此部分可省略。 返回值类型明确情况下，也可省略，由编译器对返回类型进行推

导 。

{statement} ：函数体 。在该函数体内，除了可以使用其参数外，还可以使用所有捕获

到的变量。

事实上lalmbda本质就是一个函数对象，我们一般这样去使用它：

int main()
{
	//比如简单写一个打印出入的参数
auto it=	[]       (int x)    ->int   { cout << x; return 0; };
           //捕捉列表  参数列表  返回类型   函数体
 //我们一般用auto自定推导类型来获取这个对象
   it(1);//对象传参
//当然我们也可以省略返回值类型，它可以自动推导
//auto it=[](int x){ cout << x; return 0; };

   return 0;
}

 那么我们就可以用lambda去替换仿函数。

现在我们就可以用lambda表达式去实现仿函数一样的功能：

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
	//仿函数
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());
	//lambda
	//这里的lambda可以理解为匿名函数对象
	sort(v.begin(), v.end(), [](Goods &it1,  Goods& it2) {return it1._price > it2._price; });
	sort(v.begin(), v.end(), [](Goods &it1, Goods& it2) {return it1._price < it2._price; });

	return 0;
}

因为sort函数提供的是模板（对于比较这一部分），因此我们只要传参可调用的对象就可以。

那么有人就开始疑惑了，lambda返回类型到底是一个什么？通过typeid我们可以看看：

int main()
{
	auto p=[](Goods& it1, Goods& it2) {return it1._price > it2._price; };
	auto q = [](Goods& it1, Goods& it2) {return it1._price > it2._price; };
	cout << typeid(p).name()<<endl;
	cout << typeid(q).name()<<endl;
}

 实际上是一个类,每个lambda都有自己对应的类。

关于捕捉列表，lambda表的是其他构成我们能理解，但对于捕捉列表是什么呢？

所谓的捕捉，就是可以将父作用域里的变量直接拿来使用，但传值过来的变量无法被修改。

除了传值，也可以传引用捕捉，但在书写方面与取地址写法一样，注意别混淆。

传值就是普通函数传参，传引就是引用传参。如果想捕捉地址，就实现把地址取出来。

当然捕捉引用时，它自动传参时，此时就不再使用mutable了。

即：

int x = 1; int y = 2;
	//不捕获时
		auto q = [](int x, int y)->void
	    {
		int temp = x;
		x = y;
		y = temp;
	    };
		q(x, y);
		//这里只是作为参数传递过去，形参的改变不影响实参
		cout<<x<<" " << y << endl;
		//捕获时，但注意，这里虽然捕获了，可以直接用
		//但此时默认情况下这里的函数是不能修改的，需要加入mutable表示可修改
		auto p = [x, y]()mutable-> void 
	    {
		int temp = x;
		x = y;
		y = temp;
	    };
		p();
		//这里只是作为参数传递过去，形参的改变不影响实参
		cout << x << " " << y << endl;
		auto n = [&x, &y]()-> void
		{
			int temp = x;
			x = y;
			y = temp;
		};
		n();
		//这里是传引用，因此会完成交换
		cout << x << " " << y << endl;

lambda的原理也是仿函数。

十，包装器

function

有了仿函数，lambda，实际上还有函数指针，这三个本质其实都一样，都是一个函数，可以被其他对象调用去实现某个功能。因为除了函数指针和仿函数还能传，lanmbda的类型我们是不得而知的，需要function去将这些包装，我们能直接获取其类型。

因此在c++11中又提出一个概念包装器，就是跟适配器一样。

我们之前学习单链表，栈和队列等就是用vector，list去适配出这样的一个结构。

而这里的包装器，就是用函数指针，或者lambda，仿函数去适配（包装）我们所需要的一个“函数对象”，去被调用。

语法：class function

std::function 在头文件 < functional >

// 类模板原型如下

template < class T > function ;     

template < class Ret , class ... Args >

class function < Ret ( Args ...) > ;

模板参数说明：

Ret : 被调用函数的返回类型

Args… ：被调用函数的形参

 function的本质就是一个类模板，适配就是去适配 仿函数，函数指针，lambda的其中一个。

//包装器 function
//我们还是以交换两个整数为例
//仿函数
struct Swap1
{
	void operator()(int& x, int& y)
	{
		int temp = x;
		x = y;
		y = temp;
	}
};
//函数
void Swap2(int& x,int& y)
{
	int temp = x;
	x = y;
	y = temp;
}
//lambda
auto Swap3 = [](int& x, int& y)->void {int temp = x; x = y; y = temp; };
//首先我们先来使用一下
int main()
{
	int x = 1; int y = 2;
	//可以包装这三个
	function<void(int&, int&)> p1 = Swap1();
	p1(x, y);
	cout << x << " " << y << endl;
	function<void(int&, int&)> p2 = Swap2;
	p2(x, y);
	cout << x << " " << y << endl;
	function<void(int&, int&)> p3 = Swap3;
	p3(x, y);
	cout << x << " " << y << endl;
	//通过function模板 ，在传入参数时，我们就可以选择三个其中之一进行传参
	map<string, function<void(int&, int&)> >  op = { {"仿函数", Swap1()},{"函数指针", Swap2},{"lambda", Swap3} };
	/*m.insert(make_pair("仿函数", Swap1()));
	m.insert(make_pair("函数指针", Swap2));
	m.insert(make_pair("仿函数", Swap3));*/
	//map<string, function<void(int&, int&)> >  m = { {"仿函数", p1},{"函数指针", p2},{"仿函数", p3} };
	op["仿函数"](x, y); 
	op["函数指针"](x, y);
	op["lambda"](x, y);

}

当然这里我们的函数的参数类型是一样的。

包装成员函数

在包装成员函数时，我们需要注意几点：

1.指定类域

2.要在成员函数前加&符号，才表示成员函数的地址

3.传参需要加入他的地址

class Func
{
public:
	static int Add1(int x, int y)
	{
		return x + y;
	}
	double Add2(double  x, double  y)
	{
		return x + y;
	}
};
int main()
{
	//如果是static，我们可以直接包装
	function<int(int, int)> p1 = Func::Add1;
	cout << p1(1, 2)<<endl;
	//如果是普通成员函数,则还需要一个对象指针
	Func a;
	function<double(Func*, double, double)> p2 = &Func::Add2;
	cout << p2(&a, 1.1, 2.1) << endl;
	//对象也可以
	function<double(Func a, double, double)> p3 = &Func::Add2;
	Func b;
	cout << p3(b,1.2, 2.3) << endl;
}

bind

除了function，还有第二个包装器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 )

 可以用来调整参数的位置，

int main()
{
 //表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
 std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
 
 //表示绑定函数 plus 的第一，二为： 1， 2
 auto  func2 = std::bind(Plus, 1, 2);   
 cout << func1(1, 2) << endl;
 cout << func2() << endl;
}