//创建对象时也可以使用列表初始化方式调用构造函数初始化
template<class T>
class Example
{
public:Example(T a,T b):_a(a),_b(b){}
private:int _a;int _b;
};
int main()
{Example<int> a{ 1,2 };Example<double> a={ 1.2,2.5 };return 0;
}

2.2 initializer_list

        此类型用于访问 C++ 初始化列表中的值，该列表是 const T 类型的元素列表。此类型的对象由编译器根据初始化列表声明自动构造，该声明是用大括号括起来的逗号分隔元素的列表。

		vector(initializer_list<T> l){_start = new T[l.size()];_finish = _start + l.size();_endofstorage = _start + l.size();iterator it = _start;typename initializer_list<T>::iterator it1 = l.begin();while (it1 != l.end()){*it++ = *it1++;}}vector<T>& operator=(initializer_list<T> l){//调用构造vector<T> tmp(l);std::swap(_start, tmp._start);std::swap(_finish, tmp._finish);std::swap(_endofstorage, tmp._endofstorage);return *this;}

#include<map>
int main()
{auto pf = strcpy;cout << typeid(pf).name() << endl;int i = 10;auto p = &i;cout << typeid(p).name() << endl;map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };//map<string, string>::iterator it = dict.begin();auto it = dict.begin();   //自动类型推断return 0;
}

3.2 decltype

int main()
{//左值int* ptr = new int[10]{ 0 };int a = 10;const int  c = 20;//左值引用int*& pp = ptr;int& d = a;//定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。//c = 3;   不能赋值const int& rc = c;int& pvalue = *ptr;return 0;
}

4.1.2 右值引用

右值引用绑定到右值（rvalue），即临时对象或表达式的结果。右值引用通常用于移动语义和完美转发，它们允许我们有效地转移资源的所有权或延长临时对象的生命周期。右值引用使用 && 符号声明。

int&& rref = 10; // rref 是 10 的右值引用

4.2 右值引用使用场景和意义

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
using namespace std;
namespace stringtest
{class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}string(const char* str = ""):_size(strlen(str)), _capacity(_size){//cout << "string(char* str)" << endl;_str = new char[_capacity + 1];strcpy(_str, str);}// s1.swap(s2)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};
}void func(stringtest::string s1)
{}
void func2(const stringtest::string& s)
{}int main()
{stringtest::string s1("hello world");func(s1);func2(s1);//左值引用减少了拷贝//string operator+=(char ch)s1 += 'h';return 0;
}

左值引用的短板：

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。string to_string(int value) 函数中可以看到，这里只能使用传值返回，传值返回会导致至少1 次拷贝构造 ( 如果是一些旧一点的编译器可能是两次拷贝构造 ) 。

namespace stringtest
{stringtest::string to_string(int value){bool flag = true;if (value < 0){flag = false;value = 0 - value;}stringtest::string str;while (value > 0){int x = value % 10;value /= 10;str += ('0' + x);}if (flag == false){str += '-';}std::reverse(str.begin(), str.end());return str;}
}int main()
{stringtest::string s1 = stringtest::to_string(1235433);return 0;
}

通过观察