《C++标准库第2版》3.1 C++11语言新特性笔记

3.1 C++11 语言新特性

3.1.1 微小但是重要的语法提升

1.template 表达式内的空格

在两个template表达式的闭符之间放一个空格已经过时，目前两个版本的C++11以后两个版本都支持

cpp 复制代码

vector<list<int> >; // 这是以前的版本
vector<list<int>>;  //这是C++11以后可以书写的版本

2.nullptr 和std::nullptr_t

C++11允许使用nullptr取代0或NULL来给指针赋值。

nullptr是个新的关键字，自动被转换成各种pointer类型，但不会被转换为任何整数类型。

std::nullptr_t被视为一个基础类型

3.1.2 以auto完成类型的自动推导

C++11允许你声明一个变量或对象而不需指明自类型，只需要说它是auto。但是需要一个初始化操作。（其类型是根据其初值自动推导出来的）

cpp 复制代码

    auto i = 333;
    auto ii = 333.33;
    auto iii = new MyClass();
    auto iiii = std::make_shared<MyClass>();
    // 原本使用这个格式定义的
    //std::shared_ptr<MyClass> iiii = std::make_shared<MyClass>();
    auto iiiii; //declaration of 'auto iiiii' has no initializer

3.1.3 一致性初始化与初值列

一致性初始化：

面对任何初始化动作，都可以使用相同的语法，也就是大括号；

初值列：

会强迫造成所谓value initialization,意思是即使某个local变量属于某种基础类型，也会被初始化为0（或nullptr,如果它是个指针）

窄化：

精度降低或者数值变动，对大括号而言是不可成立的。（使用大括号赋值，如果精度或者数值变动，就会报错）

用户自定义初值列

C++11提供了class template std::initializer_list<>,用来支持一系列值进行初始化，或者"你想要处理一系列值"的任何地方进行初始化。

cpp 复制代码

#include <iostream>
#include <memory>
#include <vector>
#include <string>
class MyClass
{
public:
    MyClass(int a, int b) { std::cout << "2 args" << std::endl; }
    MyClass(std::initializer_list<int> values) { std::cout << "std::initialization_list<int>" << std::endl; }
    ~MyClass() = default;
};

void functionsList(std::initializer_list<int> values)
{
    std::cout << "functionsList" <<std::endl;
}


int main(int argc, char const *argv[])
{
    // 都是用大括号完成初始化
    int values[]{2, 3, 4, 5};
    std::vector<int> v{2, 4, 6, 8, 100};
    std::vector<std::string> vs{"hello", "world"};

    // 初值列会强迫造成value initialization
    int i;    // 随机值
    int j{};  // 初值为0
    int *p;   // 随机值
    int *q{}; // 初始化为nullptr

    // 精度或者数值变化，会导致大括号赋值方式报错
    int x1(5.3);  // 使用括号赋值，没问题
    int x2 = 5.3; // 使用等号赋值，也没问题
    //int x3{5.3};  // 报错：narrowing conversion of '5.2999999999999998e+0' from 'double' to 'int' inside { }

    // 可以使用 class template std::initializer_list<>来支持初始化列。
    MyClass m{1,2,3,4,5,6};
    functionsList({12,3213,12341,234,12,34,1});


    // 如果实参数量正好与构造函数的形参数量一致，只要是使用了大括号，也不会调用"指明实参数量"的构造函数
    MyClass mm(1,23);
    MyClass mmm {1,2,3,4,5,6,};
    MyClass mmmm {1,2};  // 实参数量，刚好满足MyClass(int a, int b),但是还是调用初值列的版本。如果没有初值列版本，数量符合就调用指定实参数量的版本，不会报错。
    return 0;
}

由于初值列的关系，explicit 对于"接受一个以上实参"的构造函数也变得关系重大。即便是使用=语法，"多数值自动类型转换"也不再起作用

同样的explicit构造函数如果接受的是个初值列，会失去"初值列带有0个、1个或多个初值"的隐式转换能力。

cpp 复制代码

#include <iostream>
class MyClass
{
public:
    MyClass(int a, int b) { std::cout << "2 args" << std::endl; }
    explicit MyClass(int a, int b, int c) { std::cout << "explicit 3 args." << std::endl; }
    ~MyClass() = default;
};

void fp(const MyClass &cmc)
{
    std::cout << "hello fp" << std::endl;
}

int main(int argc, char const *argv[])
{
    // 常规使用括号赋值
    MyClass mc1(1, 2);
    MyClass mc2(1, 2, 3);

    // 使用初始化列
    MyClass mc3{1, 2};
    MyClass mc4{12, 3, 4};

    // 使用初始化列和等号
    MyClass mc5 = {1, 2};

    // MyClass mc6 = {1,2,3}; // 报错： converting to 'MyClass' from initializer list would use explicit constructor 'MyClass::MyClass(int, int, int)'
    fp({47, 11});
    // fp({11,11,12}); // converting to 'const MyClass' from initializer list would use explicit constructor 'MyClass::MyClass(int, int, int)'
    fp(MyClass{12, 123});
    fp(MyClass{12, 123, 123});
}

3.1.4 Range-Based for循环

基本格式;

cpp 复制代码

for (decl:coll)
{
	statement
}

对于decl 有传值、传const引用，传引用

传值：for循环的语句会作用域元素的一份local copy身上。在每一次循环都会调用每个元素的copy构造函数和析构函数。

传const引用：避免每次循环调用每个元素的copy构造函数和析构函数，同时也避免在语句中修改元素的值

传引用：在希望修改元素的值的情况下使用这个。

注意事项：

coll提供成员函数begin()和end()

在for循环中被初始化为decl，不得有任何显式类型转换

cpp 复制代码

#include <iostream>
#include <vector>
#include <string>
class C
{
public:
    explicit C(const std::string& s) {}
    ~C() = default;
};

int main(int argc, char const *argv[])
{
    std::vector<int> vis{1, 23, 4, 5, 5, 123, 123};

    for (auto vi : vis)
    {
        std::cout << "vi = " << vi << std::endl;
    }

    for (const auto &cfvi : vis)
    {
        std::cout << "cfvi = " << cfvi << std::endl;
    }

    for (auto &fvi : vis)
    {
        std::cout << "fvi = " << fvi << std::endl;
    }

    // 这个会报错：invalid initialization of reference of type 'const C&' from expression of type 'std::__cxx11::basic_string<char>'
    // std::vector<std::string> vss{"hello", "world"};
    // for (const C &elem : vss)
    // {
    //     ;
    // }
}

3.1.5 Move语义和Rvalue Reference

C++11的一个重要的特性就是，支持move semantic(搬迁语义)。避免了非必要拷贝和临时对象

程序员必须自行指明"move是可行的，除非被安插的那个临时对象还会被使用"

C++标准库的class保证了，再一次move之后，对象处于有效但不确定的状态。也就是说，可以在move之后对它赋予新值。

cpp 复制代码

#include <iostream>
#include <string>
#include <utility>

int main(int argc, char const *argv[])
{
    std::string xxx{"asdasdassd"};
    std::cout << "xxx = "<< xxx <<std::endl;
    std::string xxx1(std::move(xxx));
    std::cout << "xxx = "<< xxx <<std::endl;
    std::cout << "xxx1 = " <<  xxx1 << std::endl;
    return 0;
}

// xxx = asdasdassd
// xxx =
// xxx1 = asdasdassd
# 可以明显看到xxx在使用了move以后，内容被移走了（被偷后只剩个空壳子）

nontrivial class: 如果一个类的构造函数不是编译器自动生成的那么他就是nontrivial class。主要释义在下本的看的书《STL源码剖析》中。

Rvalue和Lvalue Reference的重载规则（用一段代码体现）：

cpp 复制代码

#include <iostream>
#include <string>
#include <utility>

// 只实现void foo(x&),只能左值调用
void foo(std::string &test)
{
    std::cout << "foo(std::string &)" << std::endl;
}

// 只实现void foo1(const x&)
void foo1(const std::string &test)
{
    std::cout << "foo1(const std::string &)1" << std::endl;
}

// 实现foo2(x&)/foo2(x&&)
void foo2(std::string &test)
{
    std::cout << "foo2(std::string &)" << std::endl;
}

void foo2(std::string &&test)
{
    std::cout << "foo2(std::string &&)" << std::endl;
}

// 实现foo3(x&&)
void foo3(std::string &&test)
{
    std::cout << "foo3(std::string &&)" << std::endl;
}

int main(int argc, char const *argv[])
{
    std::string xxx{"asdasdassd"};

    // foo只能左值调用，不能右值调用，会报错
    foo(xxx);
    // foo(std::move(xxx));

    // foo1可以左值，也可以右值
    foo1(xxx);
    foo1(std::move(xxx));
    xxx = std::string("hello");

    // foo2可以区分左右值调用，调用不同的函数
    foo2(xxx);
    foo2(std::move(xxx));

    xxx = std::string("hello");

    // foo3只能右值调用，左值会报错
    // foo3(xxx);
    foo3(std::move(xxx));
    return 0;
}

// 输出：
// foo(std::string &)
// foo1(const std::string &)1
// foo1(const std::string &)1
// foo2(std::string &)
// foo2(std::string &&)
// foo3(std::string &&)

前面都是说做参数，如果Rvalue reference作为返回值呢？

很明确：你不需要也不应该move()返回值。

3.1.7 关键字noexcept

C++11提供了关键字noexcept,用来指明某个函数无法----或不打算抛出异常

若异常没有在内部处理，一旦异常抛出，程序会终止，然后std::terminate()被调用并默认调用std::abort()

可以指明在某些条件下不抛出异常

cpp 复制代码

#include <iostream>
#include <string>

// 因为声明了不抛出异常，一旦抛出异常，程序直接挂掉。这个抛出的异常外面无法捕获。
void foo(int x, int y) noexcept
{
    throw 1;
}

// 可以带一个"常量表达式"作为参数
void foo1(int a, int b) noexcept(false)
{
    throw 2;
}

// 这个里面抛出的异常是可以被捕获的。
void foo2(int a, int b)
{
    throw 3;
}

int main()
{
    try
    {
        foo1(13, 12);
        // foo(123,12);
        // foo2(123,123);
    }
    catch (int e)
    {
        std::cout << "error:" << e << '\n';
    }
}

3.1.8 关键字constexpr

自C++11起，constexpr 可用来让表达式核定于编译期。

以下内容源自微软的官方文档（路径就不贴了）

constexpr由C++11引入，完善于C++14

基本格式：

CPP 复制代码

constexpr literal-typeidentifier=constant-expression;
constexpr literal-typeidentifier{constant-expression};
constexpr literal-typeidentifier(params);
constexpr ctor(params);

cpp 复制代码

class MyConstexprClass
{
public:
    constexpr MyConstexprClass(int ina, int inb) : a(ina), b(inb) {}
    ~MyConstexprClass() = default;

private:
    int a;
    int b;
};

class MyClass
{
public:
    MyClass(){}
    ~MyClass() = default;

private:
    int a;
    int b;
};
// 由于不同的编译器可能表现不一样，还有就是C++标准不一样constexpr的限定也不一样。所以有关constexpr函数和class就不介绍了
int main(int argc, char *argv[])
{
    constexpr int a = 11;
    constexpr float b = 1.1;
    constexpr char c = 2;
    constexpr double d = 23.324;

    // 这个报错：uninitialized
    //constexpr double d1;

    // 报错 string 不是一个文本类型
    // constexpr std::string str("132132465465");
    
    constexpr MyConstexprClass aaa(11, 12);
    constexpr MyConstexprClass aaa1 = aaa;
    constexpr MyClass  cmc();  //这样不会报错

    // 这样报错 has no 'constexpr' constructor(部分报错内容)
    // constexpr MyClass cmc2 = cmc;

    return 0;
}

3.1.9 崭新的Template特性

1.从C++11起，template可以有"得以接受个数不定之template实参"的参数。

cpp 复制代码

#include <iostream>

void print()
{
    std::cout << " no para" << std::endl;
}

template <typename T>
void print(const T &content)
{
    std::cout << content << " one para" << std::endl;
}

template <typename T, typename... Type>
void print(const T &first, const Type &...args)
{
    std::cout << first << std::endl;
    print(args...);
}

int main(int argc, const char **argv)
{
    print(123, 12.34, "hello", "world");
    return 0;
}

// 输出
//  123
//  12.34
//  hello
//  world
//   no para

// 加上一个参数的template print后
// 123
// 12.34
// hello
// world one para

2.从C++11起，支持template type definition.使用关键字using（给template定义的内容起个别名，在使用时就方便了）

cpp 复制代码

template <typename T>
using Vec = std::vector<T>; 
Vec<int> coll;

3.从C++11起，function tempalte可拥有默认template实参。 local可被当作template实参

3.1.10 Lambda

cpp 复制代码

//完整的lambda应该长这样
auto l = [capture] (param) mutable thorwSpec ->retType {}
// 当你不想访问外部的任何数据的时候capture可以没有
// 括号是可以省略的，但是param mutable throwSpec retType 只要出现任意一个，那么括号就必须有
// param是可以省略的
// mutable 是可以省略的
// throwSpec 是可以省略的
// ->是可以省略的，这个是新式返回值声明形式，和retType绑定出现
// retType是可以省略的

//简化版
auto l = []{}

注意事项：

lambda不可以是template.你始终必须指明所有类型

每个lambda表达式的类型都是独一无二的。

capture :捕获方式（其实类似参数传递方式，可以是byvalue/byreference。但是这个是表明访问lambda外部nonstatic对象的方式）

cpp 复制代码

#include <iostream>

int main(int argc, char const *argv[])
{
    int a = 1, b = 2, c = 3;
    // byvalue
    auto labv = [=]
    {
        std::cout << a + b + c << std::endl;
        //a++; //无法修改捕获对象的值
    }; //这个分号别忘了。（忘了也没事，反正编译不过）

    // by reference
    auto larf = [&]
    {
        a++;
        b++;
        c++;
    };

    // 还可以分别指定每一个参数的方式,但是这样就必须指明被捕获的对象的名称，直接写名称就代表byvalue.
    auto larl = [a, &b, c]
    {
        std::cout << a << b << c << std::endl;
        b++;
    };

    // 可以先指定一个默认的捕获方式，然后再指明某个对象的特殊的捕获方式
    auto larl1 = [=,&c]
    {
        std::cout << a << b << c << std::endl;
        c++;
    };

    //这样不会报错，但是有警告,还是别这样写了。看起来就很别扭
    // auto larl2 =  [=,c]  
    // {
    //     std::cout << a << b << c << std::endl;
    // };

    // auto larl3 = [&,&c]{
    //     std::cout << a << b << c << std::endl;
    // };

    // 如果想在lambda内修改捕获的对象，但是呢又不想影响对象外面的值那么就添加mutable
    auto lam = [=]() mutable{
        a++;
        b++;
        c++;
        std::cout << "a = " << a << ",b = " << b << ",c = " << c << std::endl;
    };

    // 调用方式
    labv();                                                                // 6
    std::cout << "a = " << a << ",b = " << b << ",c = " << c << std::endl; // a = 1,b = 2,c = 3
    larf();
    std::cout << "a = " << a << ",b = " << b << ",c = " << c << std::endl; // a = 2,b = 3,c = 4
    larl();                                                                // 133, 这里有个疑问a/c不是在上一步改成了2/4了么？
    std::cout << "a = " << a << ",b = " << b << ",c = " << c << std::endl; // a = 2,b = 4,c = 4
    larl1();                                                               // 124
    std::cout << "a = " << a << ",b = " << b << ",c = " << c << std::endl; // a = 2,b = 4,c = 5
    lam();                                                                 // a = 2,b = 3,c = 4
    std::cout << "a = " << a << ",b = " << b << ",c = " << c << std::endl; // a = 2,b = 4,c = 5
    return 0;
}
// 补充知识点：
// 使用值传递时，编译器将lambda中的捕获的变量值初始化为main函数中的同名变量的值，之后，lambda中的捕获变量与main函数中的同名变量不再有任何关系。
// 使用引用传递时则不同，lambda中的捕获变量为main函数中同名变量的副本，两者在内存中的地址是相同的。

3.1.11 关键字decltype

使用方式：decltype(expression)

作用：让编译器找出expression的类型。

使用场景：

声明返回类型

在超编程中

传递lambda的类型

3.1.12 新的函数声明语法

C++11以后，可以将一个函数的返回类型声明于参数列之后。

cpp 复制代码

#include <iostream>
// 新的函数声明语法

// 出现在声明中，不行。
// func1(int x,int y)->int; 

int func1(int x, int y)
{
    return x+y;
}

// 出现在定义中,这样也不行，编译报错
// 'func2' function with trailing return type not declared with 'auto' type specifier
// func2(int x)->int
// {
//     return x;
// }

// 查了资料后,编译通过，普通已知返回类型的函数，这样写感觉意义不大，感觉只需要知道有这么个写法就行
auto func(int x, int y) ->int;  //
auto func(int x, int y)->int
{
    return x+y;
}

// 看看书上的例子，用的是function template, 个人感觉：用在返回类型未知的地方比较合理。
template <typename T1, typename T2>
auto add(T1 x, T2 y) ->decltype(x+y);

template <typename T1, typename T2>
auto add(T1 x, T2 y) ->decltype(x+y)
{
    return x + y;
}

int main(int argc, const char **argv)
{
    std::cout << add(11.2, 11) << std::endl;

    return 0;
}

3.1.13 带领域Enumeration

名称：scoped enumeration/strong enumeration/enumeration class

格式：

cpp 复制代码

enum class enumname:int{...};// int 可以换成其它类型，默认就是int

注意事项：

1.绝不对隐式转换至/自int

2.如果数值不再enumeration声明的作用域内，必须使用enum name::数值

3.可以显示定义一个低层类型，获得一个保证大小。如果省去，默认为int

4.提前声明enumeration type是可能的，那会消除"为新的enumeration value而重新编译的必要"的必要--如果只是类型被使用。

cpp 复制代码

#include <iostream>

// 先回顾以前的枚举的定义

// 带名字
enum myenum
{
    FAILED,
    SUCCESS,
    OUT_RANGE
};

// 不带名字
enum
{
    FAILED1,
    SUCCESS1 = 2, // 可以修改值，然后后面的就是自动+1
    OUT_RANGE1
};

// scoped enumeration
// 可以显示定义低层类型（char）,并因此获得一个保证大小，不写的话默认为int
enum class Salutation : char
{
    mr,
    ms,
    co,
    none
};
// using SA = enum class Salutation: char{mr, ms,co,none}; //可以用using 起个别名，Salutation太长了。

int main(int argc, char const *argv[])
{
    int a = OUT_RANGE1; 
    std::cout << a << std::endl;

    // 1.绝不会隐式转换至/自int
    //  int b = SA::co; // 报错无法完成转换

    // 2.如果数值不在enumeration被声明的作用域内，使用enumname::数值
    //  int b1 = mr // mr' was not declared in this scope
    int c = static_cast<int>(Salutation::none);

    return 0;
}

3.1.14 新的基础类型

char16_t 和char32_t

long long 和unsigned long long

std::nullptr_t

cpp 复制代码

#include <iostream>
#include <memory>
int main(int argc, char const *argv[])
{
    std::cout << "sizeof(char16_t) = " << sizeof(char16_t) << std::endl;
    std::cout << "sizeof(char32_t) = " << sizeof(char32_t) << std::endl;
    std::cout << "sizeof(long long) = " << sizeof(long long) << std::endl;
    std::cout << "sizeof(unsigned long long) = " << sizeof(unsigned long long) << std::endl;
    std::cout << "sizeof(nullptr) = " << sizeof(nullptr) << std::endl;
    return 0;
}

// 结果
// sizeof(char16_t) = 2
// sizeof(char32_t) = 4
// sizeof(long long) = 8
// sizeof(unsigned long long) = 8
// sizeof(nullptr) = 8

《C++标准库第2版》3.1 C++11语言新特性 笔记

3.1 C++11 语言新特性

3.1.1 微小但是重要的语法提升

3.1.2 以auto完成类型的自动推导

3.1.3 一致性初始化与初值列

3.1.4 Range-Based for循环

3.1.5 Move语义和Rvalue Reference

3.1.7 关键字noexcept

3.1.8 关键字constexpr

3.1.9 崭新的Template特性

3.1.10 Lambda

3.1.11 关键字decltype

3.1.12 新的函数声明语法

3.1.13 带领域Enumeration

《C++标准库第2版》3.1 C++11语言新特性笔记