C++11
- C++11简介
- 统一的列表初始化
- ｛｝初始化
- std::initializer_list
- 声明
- auto
- decltype
- nullptr
- 范围for循环
- STL中一些变化
- array
- forward_list
- underored_map，underored_set
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++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多。
统一的列表初始化
｛｝初始化
在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：
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;
}
C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。注意：{}对于new的使用是不可添加等号的；
struct Point
{
int _x;
int _y;
};
int main()
{
int x1 = 1;//可添加等号
int x2{ 2 };//可不添加等号
int array1[]{ 1, 2, 3, 4, 5 };//可不添加等号
int array2[5]{ 0 };//可不添加等号
Point p{ 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;
}
std::initializer_list
C++11中新增了initializer_list容器，该容器没有提供过多的成员函数：
那么initializer_list是什么类型呢？
我们看下面这段代码：
int main()
{
auto il = { 10, 20, 30 };
cout << typeid(il).name() << endl;//class std::initializer_list<int>
return 0;
}
initializer_list本质就是一个大括号括起来的列表，如果用auto关键字定义一个变量来接收一个大括号括起来的列表，然后以typeid(变量名).name()的方式查看该变量的类型，此时会发现该变量的类型就是initializer_list。
initializer_list容器没有提供对应的增删查改等接口，因为initializer_list并不是专门用于存储数据的，而是为了让其他容器支持列表初始化的。
class Date
{
public:
Date(int year, int month, int day)
:_year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
int main()
{
vector<int> v{ 1,2,3,4,5 };
list<int> lt{ 1,2,3,4,5 };
map<string, string> mp{ {"排序","sort"},{"左边","left"},{"右边","left"} };
Date d1{ 2022,9,22 };
vector<Date> dv{ {2022,9,22},{2022,9,21},{2022,9,20} };
}
例如我们自己实现的vector，如果要让其支持列表初始化，就需要增加一个以initializer_list作为参数的构造函数：
namespace gtt
{
template<class T>
class vector
{
public:
typedef T* iterator;
vector(initializer_list<T> il)
{
_start = new T[il.size()];
_finish = _start;
_endofstorage = _start + il.size();
//迭代器遍历
//typename initializer_list<T>::iterator it = il.begin();
//while (it != il.end())
//{
// push_back(*it);
// it++;
//}
//范围for遍历
for (auto e : il)
{
push_back(e);
}
}
vector<T>& operator=(initializer_list<T> il)
{
vector<T> tmp(il);
std::swap(_start, tmp._start);
std::swap(_finish, tmp._finish);
std::swap(_endofstorage, tmp._endofstorage);
return *this;
}
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
};
}
声明
auto
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型推断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。
int main()
{
int i = 10;
auto p = &i;
auto pf = strcpy;
cout << typeid(p).name() << endl;//int *
cout << typeid(pf).name() << endl;//char * (__cdecl*)(char *,char const *)
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
//map<string, string>::iterator it = dict.begin();
auto it = dict.begin();
return 0;
}
decltype
关键字decltype将变量的类型声明为表达式指定的类型：
template<class T1, class T2>
void F(T1 t1, T2 t2)
{
decltype(t1 * t2) ret;
cout << typeid(ret).name() << endl;//int
}
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;//double
cout << typeid(p).name() << endl;//int*
F(1, 'a');
return 0;
}
同样，decltype除了能够推演表达式的类型，还能推演函数返回值的类型：
int Add(int a, int b)
{
return a + b;
}
int main()
{
int a = 1;
int b = 2;
double c = 3.0;
cout << typeid(Add(a, b)).name() << endl;//int
return 0;
}
我们需要注意的是decltype与auto是存在区别的，decltype可以获取一个变量的类型，但无法用获取到的这个类型去定义变量，而auto是可以定义变量类型的。
int main()
{
int a = 1;
double b = 1.1;
auto c = a + b;
//decltype d = a + b;这样还不可以的
decltype (a + b) d;
cout << typeid (c).name() << endl;//double
cout << typeid (d).name() << endl;//double
return 0;
}
nullptr
由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
在大部分情况下使用NULL不会存在什么问题，但是在某些极端场景下就可能会导致匹配错误：
void func(int* ptr)
{
cout << "void func(int* ptr)" << endl;
}
void func(int ptr)
{
cout << "void func(int ptr)" << endl;
}
int main()
{
func(NULL); //void func(int ptr)
func(nullptr); //void func(int* ptr)
return 0;
}
范围for循环
我们在C++98中遍历一个数组的方式是下面这样：
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9 };
int n = sizeof(arr) / sizeof(arr[0]);
//普通方法遍历数组
for (int i = 0; i < n; i++)
{
cout << arr[i] << " ";//1,2,3,4,5,6,7,8,9
}
cout << endl;
return 0;
}
而在C++11中增加了范围for循环：
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9 };
//范围for遍历数组
for (auto e : arr)
{
cout << e << " ";//1,2,3,4,5,6,7,8,9
}
cout << endl;
return 0;
}
范围for的底层实际上就是迭代器，只要我们将迭代器实现，范围for实际上也就实现了；
STL中一些变化
在C++11中，STL库中又新增了四个容器：arrary，forward_list，underored_map，underored_set。
array
array容器本质就是一个静态数组，即固定大小的数组。
array容器有两个模板参数，第一个模板参数代表的是存储的类型，第二个模板参数是一个非类型模板参数，代表的是数组中可存储元素的个数。
int main()
{
array<int, 5> a1;//定义一个可存储5个int类型元素的array容器
array<double, 10> a2;//定义一个可存储10个double类型元素的array容器
return 0;
}
array容器与普通数组对比：
- array容器与普通数组一样，支持通过[]访问指定下标的元素，也支持使用范围for遍历数组元素，并且创建后数组的大小也不可改变。
- array容器与普通数组不同之处就是，array容器用一个类对数组进行了封装，并且在访问array容器中的元素时会进行越界检查。用[]访问元素时采用断言检查，调用at成员函数访问元素时采用抛异常检查。
而对于普通数组来说，一般只有对数组进行写操作时才会检查越界，如果只是越界进行读操作可能并不会报错。
但array容器与其他容器不同的是，array容器的对象是创建在栈上的，因此array容器不适合定义太大的数组。
forward_list
forward_list容器本质就是一个单链表。
forward_list很少使用，原因如下：
- forward_list只支持头插头删，不支持尾插尾删，因为单链表在进行尾插尾删时需要先找尾，时间复杂度为O(N)。
- forward_list提供的插入函数叫做insert_after，也就是在指定元素的后面插入一个元素，而不像其他容器是在指定元素的前面插入一个元素，因为单链表如果要在指定元素的前面插入元素，还要遍历链表找到该元素的前一个元素，时间复杂度为O(N)。
- forward_list提供的删除函数叫做erase_after，也就是删除指定元素后面的一个元素，因为单链表如果要删除指定元素，还需要还要遍历链表找到指定元素的前一个元素，时间复杂度为O(N)。
因此一般情况下要用链表我们还是选择使用list容器。
underored_map，underored_set
underored_map，underored_set我们已经在前面介绍过了，需要了解的可以看前面的内容：
underored_map，underored_set模拟实现
