C++11的新特性

1、初始化列表

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    std::vector<int> v1{1, 2, 3};
    
    std::cout << "v1 size : " << v1.size() << std::endl;
    
    return 0;
}

上述程序用C++03标准是编不过去的。

2、auto 自动类型推导

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    std::vector<int> v1{1, 2, 3, 4};
    
    //c++ 03
    for(std::vector<int>::iterator it = v1.begin(); it != v1.end(); it++)
        std::cout << *it << " ";
    std::cout << std::endl;
    
    // c++ 11
    for(auto it = v1.begin(); it != v1.end(); it++)
        std::cout << *it << " ";
    std::cout << std::endl;
    
    
    return 0;
}

如果不使用auto自动类型推导的话，则需要自己写复杂的类型。

3、foreach 写法

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    std::vector<int> v1{1, 2, 3, 4};
    
    //c++ 03
    for(std::vector<int>::iterator it = v1.begin(); it != v1.end(); it++)
        std::cout << *it << " ";
    std::cout << std::endl;
    
    //c++ 11 read only
    for(auto i : v1)
        std::cout << i << " ";
    std::cout << std::endl;
    
    for(const auto& i : v1)
        std::cout << i << " ";
    std::cout << std::endl;
    
    for(auto& i : v1)
        i = 3;
    for(auto i : v1)
        std::cout << i << " ";
    std::cout << std::endl;
    
    
    return 0;
}

foreach写法。

4、nullptr代替了C++03 的NULL

5、enum class 代替了C++03的enum

#include <iostream>
#include <vector>

using namespace std;

enum type1{a, b, c};


int main()
{
    // 虽然a的类型被定义为type1，但是引用a的时候可以直接引用，也就是说这里的enum是弱类型的，加不加都一样
    if(a == 0)
        std::cout << "type1::a == 0" << std::endl;
    
    return 0;
}

弱类型测试，运行结果：

 

 可以看到我们在main函数中直接使用a也是可以的，也就是说enum定义的type1是弱类型，所以如果多个enum中定义了相同的符号就会报符号冲突的错误。

#include <iostream>
#include <vector>

using namespace std;

// 非强类型的作用域
// C中的匿名enum, 两种枚举类型都有a枚举常量，而且作用域相同，发生了冲突
//enum type1{a, b, c};
//enum type2{a, d, e};

enum type1{a, b, c};
enum type2{d, e, f};

enum type3{h=1, i=0xFFFFFFFFFLL};

int main()
{
    // 不同的enum类型可以互相比较，因为编译器首先将enum转换为int类型，再做的比较
    if(type1::a == type2::d)
        std::cout << "type1::a == type2::d" << std::endl;
    
    // 占用的存储空间及符号不确定
    std::cout << sizeof(type3::h) << std::endl;
    std::cout << sizeof(type3::i) << std::endl;
    
    return 0;
}

如果type1和type2中定义相同名字的成员则会报错，因为enum是弱类型的。非强类型作用域。

两种不同enum常量比较没有意义，但是编译器先将enum常量转换成int类型后再比较，不会报错

运行结果：

 

 可以看出打印的大小都是8，因为b是一个比较大的数，所以按最大的来。

 C++11中enum的强作用域：

#include <iostream>

using namespace std;

enum class type4:int{a, b, c}; // 指定底层类型
enum class type5{a, b, c};   // 不指定底层类型


int main()
{
    type4 t = type4::a;  //必须指定强类型名称
    type4 p = a;
    
    return 0;
}

12行的a没有指定强类型，编译报错。

 

 不同类型之间也不能直接赋值。

#include <iostream>

using namespace std;

enum class type4:int{a, b, c}; // 指定底层类型
enum class type5{a, b, c};   // 不指定底层类型


int main()
{
    type4 t = type4::a;  //必须指定强类型名称
    //type4 p = a;       //这里a没有写作用域，编译报错
    
    // 相同类型可以比较
    if(t < type4::b)
        std::cout << "t < type4::b" << std::endl;
    
    // 非相同类型，不可隐式类型转换，编译报错
    //if(t < type5::b)
    //    std::cout << "t < type5::b" << std::endl;
    
    //可以强制类型转换
    if((int)t < int(type5::b) )
        std::cout << "(int)t < int(type5::b)" << std::endl;
    
    return 0;
}

上面是强类型的测试，不会有隐式类型转换。

指定底层类型：

#include <iostream>

using namespace std;

enum class type6:char{a=1, b=2}; 
enum class type7:unsigned int{a=0xFFFFFFFF};  

int main()
{
    std::cout << "sizeof(type6::a) = " << sizeof(type6::a) << std::endl;
    std::cout << "sizeof(type7::a) = " << sizeof(type7::a) << std::endl;
    
    return 0;
}

运行结果：

 

 6、override关键字标识符

在子类中如果想重写某个虚函数，那么后面最好跟上override关键字，这样如果函数签名不小心写错的话，编译器会检查出来。

如果不写override关键字那么编译器检查不出来，这样的话相当于重新定义了一个函数，可能会引发bug。

7、final关键字

指示一个类或者虚函数不能再被重写

8、关键字default标识

强制编译器生成默认构造函数。

#include <iostream>

using namespace std;

class test
{
public:
    test(int a)
    {
        data = a;
    }
    
    test() = default;
    
private:
    int data;
};

int main()
{
    test t;
    
    return 0;
}

我们定义了一个类并且定义了构造函数，这个时候默认构造函数是会被隐藏的。如果不写第13行，那么第21行是编译不过去的，因为第21行会调用默认

构造函数，但是默认构造函数被隐藏了，所以会报错。 加上第13行强制生成一个默认构造函数就好了。

 9、关键标识delete

delete放在函数后面，便是函数不能再被调用

#include <iostream>

class dog {
public:
    dog(int age_) {
        age = age_;
    }
    
    dog(double age_) = delete;
    
    int age;
};

int main(){    
    dog(2);   
    dog(4.5); 
    
    return 0;
}

如果不加第9行，第16行是可以编译过的，因为4.5这个double类型会被强制转换为int类型而调用第5行的构造函数。

如果加上第9行，表示删掉这个构造函数，这样就不会进行隐式类型转换了，而是编译直接报错。

10、lambda 函数

#include <iostream>

int main(){    
    std::cout << [](int x, int y) {return x + y; }(3, 5) << std::endl;
}

lambda表达式方便定义一些小函数，使程序更优雅。

11、智能指针

shared_ptr、unique_ptr、weak_ptr

12、tuple元组

 tuple容器，表示元组容器，可以用于函数返回多个返回值。

tuple容器，可以使用直接初始化和make_tuple初始化，访问元素使用get<>()方法，注意，get里面的位置信息必须是常量表达式。

可以通过std::tuple_size<decltype(t)>::value获取元素数量，std::tuple_element<0, decltype(t)>::type获取元素类型。

如果tuple类型进行比较，则需要保持元素数量相同，类型可以比较（相同类型，或者可以相互转换的类型）。

无法使用for类似的方法遍历tuple容器，因为get<>()方法无法使用变量获取值。

#include <iostream>
#include <tuple>

using namespace std;

std::tuple<std::string, int>  get_tuple()
{
    std::string s("test_tuple1");
    int a{2020};
    
    std::tuple<std::string, int> t = make_tuple(s, a);
    
    return t;
}


int main()
{
    std::tuple<int, double, std::string> t1(64, 128.0, "test_tuple2");
    std::tuple<std::string, std::string, int> t2 = std::make_tuple("test_tuple3", "test_tuple4", 200);
    
    // 测试返回元素个数
    size_t num = std::tuple_size<decltype(t1)>::value;
    std::cout << "t1 size : " << num << std::endl;
    
    // 获取第一个值的元素类型
    std::tuple_element<1, decltype(t1)>::type v1 = std::get<1>(t1);
    auto v2 = std::get<1>(t1);
    std::cout << "v1 : " << v1 << std::endl;
    std::cout << "v2 : " << v2 << std::endl;
    
    // tuple的比较
    std::tuple<int, int> ti(24, 48);
    std::tuple<double, double> td(28.0, 56.0);
    
    if(ti < td)
        std::cout << "ti < td" << std::endl;
    else
        std::cout << "ti >= td" << std::endl;
    
    
    // 测试tuple的返回值
    auto ret = get_tuple();
    
    std::cout << "first : " << std::get<0>(ret) << "  , second : " << std::get<1>(ret) << std::endl;
    
    return 0;
}

运行结果：

 get也可以用在pair和array上。

get可能返回引用和常引用。这个跟参数的类型有关，使用时仔细查官方文档。

13、pair的使用

pair是将两个数据合成一个数据，当需要这样的需求时就可以使用pair，如stl中的map就是将key和value放在一起来保存。另一个应用是，当一个函数需要返回2个数据的时候，可以选择pair。

#include <iostream>
#include <utility>

using namespace std;

int main()
{
    std::pair<int, float> pair1 = make_pair(18, 3.14f);
    
    std::cout << pair1.first << " " << pair1.second << std::endl;
    pair1.first = 20;
    pair1.second = 6.28f;
    
    std::cout << pair1.first << " " << pair1.second << std::endl;
    
    std::pair<float, double> pair2(3.14f, 6.28f);
    std::cout << pair2.first << " " << pair2.second << std::endl;
    
    return 0;
}

运行结果：

 

 上面程序中可以看到pair的两种构造方式。

 14、定义常量 constexpr

  对于修饰object来说，const并未区分出编译期常量和运行期常量， 而constexpr限定在了编译期常量

  对于修饰函数来说，constexpr修饰的函数，返回值不一定是编译期常量。 # It is not a bug， It is a feature。

程序：

#include <iostream>
#include <array>

using namespace std;

constexpr int foo(int i)
{
    return i + 5;
}

int main()
{
    int i = 10;
    std::array<int, foo(5)> arr; // Ok
    
    std::cout << "arr size : " << arr.size() << std::endl;
    
    foo(i); // Call is Ok
    
    //std::array<int, foo(i)> arr1; // Error
    
    return 0;
}

上面的程序中14行的foo(5)可以在编译期确定，而array的第二个模板参数正好需要常量，所以可以编译通过。

第20行foo(i)无法在编译期确定，所以编译会报错。

constexpr修饰的函数，简单的来说，如果其传入的参数可以在编译时期计算出来，那么这个函数就会产生编译时期的值。但是，传入的参数如果不能在编译时期计算出来，那么constexpr修饰的函数就和普通函数一样了。不过，我们不必因此写两个版本，所以如果函数体适用于constexprh函数的条件，可以尽量加上constexpr。

而检测constexpr函数是否产生编译时期值的方法很简单，就是利用std::array需要编译期常值才能编译通过的小技巧。这样的话，即可检测你所写的函数是否真的产生编译期常值了。

15、decltype和auto

auto能让编译器通过初始值来进行类型推演，从而获得定义变量的类型，所以auto定义的变量必须有初始值。

auto会忽略引用，会忽略顶层const，如果希望推断出auto类型是一个顶层const，需要明确指出，例：const auto f = xxx;

当我们希望从表达式中推断出要定义的变量，但却不想用表达式的值去初始化变量，还有可能函数的返回类型为某表达式的值类型。这时候用auto就显得无力了。这时需要使用decltype，它的作用是选择并返回操作数的数据类型，在此过程中，编译器只是分析表达式并得到它的类型，却不进行实际的计算表达式的值。

decltype和auto在推导类型时还有一些深坑，需要查阅文档。

decltype还有一个用途就是在c++11引入的后置返回类型。

https://www.cnblogs.com/Excr/p/12516095.html

decltype推导规则：

1. 如果e是一个没有带括号的标记符表达式或者类成员访问表达式，那么的decltype（e）就是e所命名的实体的类型。此外，如果e是一个被重载的函数，则会导致编译错误。
2. 否则 ，假设e的类型是T，如果e是一个将亡值，那么decltype（e）为T&&
3. 否则，假设e的类型是T，如果e是一个左值，那么decltype（e）为T&。
4. 否则，假设e的类型是T，则decltype（e）为T。

16、后置返回类型

#include <iostream>
using namespace std;

template <typename _Tx, typename _Ty>
auto multiply1(_Tx x, _Ty y)
{
    return x*y;
}


/*
template <typename _Tx, typename _Ty>
auto multiply1(_Tx x, _Ty y)->decltype(x * y)
{
    return x*y;
}
*/


int main()
{
    auto ret = multiply1(30, 50);
    
    std::cout << "ret : " << ret << std::endl;
    
    return 0;
}

上面的代码用c++11标准是编译不过去的。报错如下：

 

 使用C++14标准是可以编译通过的。

如果非要使用C++11标准编译，那么需要使用后置返回类型。

#include <iostream>
using namespace std;

/*
template <typename _Tx, typename _Ty>
auto multiply1(_Tx x, _Ty y)
{
    return x*y;
}
*/

template <typename _Tx, typename _Ty>
auto multiply1(_Tx x, _Ty y)->decltype(x * y)
{
    return x*y;
}

int main()
{
    auto ret = multiply1(30, 50);
    
    std::cout << "ret : " << ret << std::endl;
    
    return 0;
}

这样使用C++11标准就可以编译通过了。

17、完美转发

#include <iostream>

using namespace std;

template<typename T>
void PrintT(T& t)
{
    cout << "lvaue" << endl;
}

template<typename T>
void PrintT(T && t)
{
    cout << "rvalue" << endl;
}

template<typename T>
void TestForward(T && v)
{
    PrintT(v);
    PrintT(std::forward<T>(v));
    PrintT(std::move(v));
}

void Test()
{
    TestForward(1);
    std::cout << std::endl;
    int x = 1;
    TestForward(x);
    std::cout << std::endl;
    TestForward(std::forward<int>(x));
}

int main()
{
    Test();
    
    return 0;
}

forward作用于一个变量，非左值引用，就返回右值引用。如果是左值引用，则返回原来的类型，也就是左值引用。

运行结果：

 

 第32行的forward<int>(x)，因为x是非左值引用，所以调用完forward之后表达式就变成了右值引用。

参考：https://www.cnblogs.com/qicosmos/p/3376241.html

 引用折叠：

https://blog.csdn.net/douzhq/article/details/89504508

完美转发是目标，也就是保证传入函数的参数是什么类型，转发给子函数时就是什么类型。

引用折叠是人为定义出来的规则，具体由forward来实现，最终达到完美转发的目标。

 https://blog.csdn.net/beyongwang/article/details/54025439?utm_source=blogxgwz6

 

18、可变参数模板