c++17 新特性

编译环境说明：gcc 8.1 + eclipse +windows 10 

eclipse cpp默认支持c++14，做c++17开发时，需要手动进行配置。

 1、关键字

1）constexpr

c++17扩展了constexpr使用范围，既可以用于if语句，也可以用于lambda表达式。

例1

template<bool ok>
constexpr void foo()
{
    //在编译期间进行判断，if和else语句不生成代码
    if constexpr (ok== true)
    {
        //当ok为true时，下面的else语句块不生成汇编代码。
        cout<<"ok"<<endl;
    }
    else
    {
        //当ok为false时，上面的if语句块不生成汇编代码。
        cout<<"not ok"<<endl;
    }
}

int main() {
    foo<true>(); //输出ok,并且汇编代码中只有cout<<"ok"<<endl;这一句。
    foo<false>();
    return 0;
}

例2： 

int main() {
    constexpr auto add1 = [](int n,int m){
        auto func1 = [=]{return n;};//func1 lambda表达式
        auto func2 = [=]{return m;};//func2 lambad表达式
        return [=]{ return func1()+func2();};
    };

    constexpr auto add2 = [](int n,int m){
        return n+m;
    };

    auto add3 = [](int n,int m){
        return n+m;
    };

    int sum1 = add1(30,40)(); //传入常量，add1在编译期计算，立即返回70.
    int sum2 = add2(sum1,4); //传入非constexpr 变量，add2的constexpr失效，变成运行期lambda.
    constexpr int sum3 = add3(1,2); //sum3为constexpr变量，传入常量值，add3编译期lambda。立即返回3.
    int sum4 = add2(10,2);//传入常量值，add2编译期计算，立即返回12.
    return 0;
}

2）static_assert

扩展static_assert用法，静态断言的显示文本可选。

static_assert(true,"");
static_assert(true); //c++17

3）auto

扩展autod的推断范围。

auto x1 = { 1, 2 }; //推断出std::initializer_list<int>类型
auto x2 = { 1, 2.0 }; //错误：类型不统一，无法推断
auto x3{ 1, 2 }; //错误：auto的聚合初始化只能一个元素
auto x4 = { 3 }; //推断出std::initializer_list<int>类型
auto x5{ 3 }; //推断出int类型

4）typename

 传统用法：a）用于模板，表示模板参数为类型；b）用于声明某名字是变量。

struct A
{
    typedef int Example;
};

//第一种用法，声明模板参数为类型
template<typename T>
struct B
{

};

struct C
{
    //第二种用法，声明某名字为类型
    typedef typename A::Example E;
};

int main() {
    //第二种用法，声明某名字为类型
    typename A::Example e;
    return 0;
}

c++17 新特性下typename用法

struct A
{
    int num;
    A()
    {
        cout<<"A Construct"<<endl;
        cout<<"template typename is:"<<typeid(T).name()<<endl;
    }
};


//此处的T可省略，X代表模板类型，T和X前的typename可替换成class
template<template<typename T> typename X>
struct B
{
    X<double> e;
    B()
    {
        cout << "B Construct" <<endl;
    }
};

int main() {
    A<B<A>> a;
    B<A> b;
    return 0;
}

5）inline

扩展用法，可用于定义内联变量，功能与内联函数相似。inline可避免函数或变量多重定义的问题，如果已定义相同的函数或变量（且该函数或变量声明为inline），编译器会自动链接到该函数或变量。如下代码，不发生错误。

//  test.h
inline void print()
{
    std::cout << "hello world" << std::endl;
}
 
inline int num = 0;
//  func.h
include "test.h"
inline void add(int arg)
{
    num += arg;
    print();
}
//  main.cpp
include "func.h"
int main()
{
    num = 0;
    print();
    add(10);
    return 0;
}

2 语法

1）折叠表达式

用于变长参数模板的解包，值支持各种运算符（和操作符），分左、右折叠。如：

template<typename ...T>
auto sum(T ... arg)
{
    return (arg + ...); //右折叠
}

template<typename ... T>
double sum_strong(T ... arg)
{
    return (arg + ... + 0);//右折叠
}

template<typename ... T>
double sub1(T ... arg)
{
    return (arg - ...);//右折叠
}

template<typename ... T>
double sub2(T ... arg)
{
    return (... - arg);//左折叠
}


int main() {
    int s1 = sum(1, 2, 3, 4, 5);//解包：((((1+)2+)3+)4+)5 = 15
    double s2 = sum(1.1, 2.2, 3.3, 4.4, 5.5, 6.6);
    double s3 = sum(1, 2.2, 3, 4.4, 5);

    double s4 = sub1(5, 2, 1, 1);//解包：(5-(2-(1-(1)))) = 3
    double s5 = sub2(5, 2, 1, 1);//解包：((((5-)2-)1-)1) = 1
    double s6 = sum_strong();//s6 = 0
    string str1("he");
    string str2("ll");
    string str3("o ");
    string str4("world");
    string str5 = sum(str1, str2, str3, str4);//str5 = "hello world"
    return 0;
}

2）结构化绑定

用一对包含一个或多个变量的中括号，表示结构化绑定，但是使用结构化绑定是时，须用auto关键字，即绑定时声明变量。

例1：

/*
 * 例子：多值返回
 */
struct S
{
    double num1;
    double num2;
};

S foo(int arg1,double arg2)
{
    double result1 = arg1 * arg2;
    long result2 = arg2/arg1;
    return {result1,result2}; //返回结构体S对象
}

int main() {
    auto[num1,num2] = foo(10,20.2); //自动推导num1为double，num2为long
    cout<<num1<<" "<<num2<<endl;
    return 0;
}

例2：

template<typename T, typename U>
struct MyStruct
{
    T key;
    U value;
};

int main() {

    list<MyStruct<int,double>> container_list;
    container_list.push_back({1,1.1});
    container_list.push_back({2,2.2});
    container_list.push_back({3,3.3});

    map<int,MyStruct<long long,char>> container_map;
    container_map[1] = {12,'a'};
    container_map[2] = {13,'b'};
    container_map[3] = {14,'c'};

    for(auto[key,value]:container_list)
    {
        cout<<"key:"<<key<<",value:"<<value<<endl;
    }

    for(auto[key,value]:container_map)
    {
        auto [value1,value2] = value;
        cout<<"key:"<<key<<",value:{"<<value1<<","<<value2<<"}"<<endl;
    }

    return 0;
}

 3）允许非类型模板参数进行常量计算

非类型模板参数可传入类的静态成员。

class MyClass
{
public:
    static int a;
};

template<int *arg>
void foo(){}
int main() {
    foo<&MyClass::a>();
    return 0;
}

4）条件分支语音初始化

在if和switch中可进行初始化。

template<long value>
void foo(int &ok){
    if constexpr(ok = 10;value>0)
    {}
}
int main() {
    int num = 0;
    if(int i = 0; i==0)
    {

    }

    foo<10>(num);

    switch(int k = 10;k)
    {
        case 0:break;
        case 1:break;
        default:break;
    }
    return 0;
}

5）聚合初始化

在初始化对象时，可用花括号对其成员进行赋值。

struct MyStruct1
{
    int a;
    int b;
};
class MyClass
{
public:
    int a;
    int b;
};

struct MyStruct2
{
    int a;
    MyStruct1 ms;
};
class MyClassA
{
private:
    int a;
    int b;
public:
    MyClassA(int x,int y):a(x),b(y){}
};

int main() {
    MyStruct1 a{10};
    MyClass b{10};
    MyClassA ma{10,20};

    MyStruct2 b1{10, 20};
    MyStruct2 c{1, {}};
    MyStruct2 d{{}, {}};
    MyStruct2 e{{}, {1, 2}};

    return 0;
}

6）嵌套命名空间

简化多层命名空间的写法

//传统写法
namespace A
{
    namespace B
    {
        namespace C
        {

        };
    };
};

//新写法
namespace A::B::C
{

};

 7）lambda表达式捕获*this的值

lambda表达式可以捕获*this的值，但是this及其成员为只读

struct MyStrcut{
    double value = 100.7;
    auto f(){
        return [this]{
            return [*this]{
                this->value = 200.2; //error: assignment of member 'MyStrcut::value' in read-only object
                return value; //正确
            };
        }();
    }
    auto g(){
        return []{
            return [*this]{}; //错误，外层lambda表达式没有捕获this
        }();
    }
};

 

8）枚举[类]对象的构造

可以给枚举[类]对象赋值

enum MyEnum
{
    value
};
enum byte : unsigned char { };
struct A { byte b; };
void f(byte){};

int main() {
//    MyEnum me {10};//错误：不能用int右值初始化MyEnum类型对象
    byte b { 42 }; //正确

//    byte c = { 42 }; //错误：不能用int右值初始化byte类型对象
    byte d = byte{ 42 }; //正确，其值与b相等
//    byte e { -1 }; //错误：常量表达式-1不能缩小范围为byte类型
//    A a1 = { { 42 } }; //错误：不能用int右值初始化byte类型对象
    A a2 = { byte{ 42 } }; //正确

    A a3{ byte{ 42 } }; //正确
//    f({ 42 }); //错误：无类型说明符
    f(byte{ 42 }); //正确
    return 0;
}

9）十六进制单精度浮点数字面值

以0x前缀开头的十六进制数，以f后缀的单精度浮点数合并，就有了十六进制的单精度浮点数。

float value = 0x1111f;

10）基于对齐内存的动态内存分配

新标准中，new和delete运算符增加按照对齐内存值来分配、释放内存空间的功能（即一个新的带内存值的new、delete运算符重载）。

函数原型：

void* operator new(std::size_t size, std::align_val_t alignment);
void* operator new[](std::size_t size, std::align_val_t alignment);
    
void operator delete(void*, std::size_t size, std::align_val_t alignment);
void operator delete[](void*, std::size_t size, std::align_val_t alignment);

参数说明：

size —— 分配的字节数。必须为alignment的整数倍。
alignment —— 指定的对齐内存值。必须是实现支持的合法对齐。
new的返回值：

成功，返回指向新分配内存起始地址的指针。

用例：

struct alignas(8) A{};
int main() {
    A *a = static_cast<A *>(::operator new(sizeof(A),static_cast<align_val_t>(alignof(A))));
    ::operator delete(a, sizeof(A), static_cast<std::align_val_t>(alignof (A)));
    return 0;
}

11）细化表达式的计算顺序

为支持泛型编程和重载运算符的广泛使用，新特性将计算顺序进行细化。

如以下有争议代码段：

map<int,int> tmp;
//对于std::map的[]运算符重载函数，在使用[]新增key时，std::map就已经插入了一个新的键值对
tmp[0] = tmp.size(); ////此处不知道插入的是{0, 0}还是{0, 1}

为解决此情况，新的计算顺序规则为：

a）后缀表达式从左到右求值。包括函数调用和成员选择表达式。

b）赋值表达式从右到左求值。包括复合赋值。

c）从左到右计算机位移操作符的操作数。

12）模板类的模板参数自动推导

在c++17之前，类模板构造器的模板参数不能像函数模板的参数一样能被自动推导，比如我们无法写：

std::pair a{1,"a"s}; //c++17
std::pair<int, string> b{1, "b"s}; // C++14及之前
在c++14之前，为了弥补这一缺陷，标准库提供std::make_pair函数，通过函数模板的模板参数实现类型推导。

//相当于std::pair<int, string> c = std::make_pair<int, string>(1, string("c"));
//这里编译器根据 std::make_pair 所带参数的类型，自动推导出了函数模板的参数。
auto c = std::make_pair(1,"c"s); 

这个解决方案不太理想，因为：

a）需要记住make_pair，make_tuple这类用于构造模板类的用法。

b）有些make_xxx函数在功能上并不等价于类模板的构造器，比如make_shared等。

在c++17中，这个问题得到了解决，类的模板构造器的模板参数同样能够被自动推导。

std::pair a{1, "a"s}; // C++17
// 相当于
// std::pair<int, string> a{1, "a"s};
// 和函数模板一样，这里编译器根据 std::pair 构造器所带参数类型，自动推导出了构造器模板的参数。

示例：

vector a1 ={1,2,3};//c++17
vector<int> a2 = {1, 2, 3};  // C++14

function f1 = [](int a){return a + 1;};  // C++17
function<int(int)> f2 = [](int a){return a + 1;};  // C++14

tuple t1{1, 2,5, "a"s};  // C++17
tuple<int, double, string> t2{1, 2.5, "a"s};  // C++14
auto t = make_tuple(1, 2,5, "a"s);  // C++14

sort(a1.begin(), a1.end(), greater{}); // C++17
sort(a1.begin(), a1.end(), greater<>{});  // C++14
sort(a1.begin(), a1.end(), greater<int>{});  // C++11

map m1 = {std::pair{1, "a"s}, {2, "b"s}}; // C++17
map<int, string> m2 = {{1, "a"s}, {2, "b"s}}; // C++14

自定义类模板中的应用

template<typename T>
struct Container{
    Container(T * prt){} //构造器1
    Container(T &v){} //构造器2
    Container(T const& v) {} // 构造器 3

    template<typename D>
    Container(T* ptr, D& deleter) {} // 构造器 4
};
struct Deleter {};

int main() {
    Container c{(int*)0}; // 调用构造器 1
    int x; Container c2{x}; // 调用构造器 2
    Container c3{0}; // 调用构造器 3
    Deleter d;
    Container c4{(int*)0, d}; // 调用构造器 4
    //以上编译器自动推导的结果都是 Container<int>
    return 0;
}

13）简化重复命名空间的属性列表

[[ using CC: opt(1), debug ]] void f() {}
//作用相同于 [[ CC::opt(1), CC::debug ]] void f() {}

14）不支持、非标准的属性

在添加属性列表时，编译器会忽略不支持的非标准的属性，不会发出警告和错误。

15）改下继承构造函数

在类的继承体系中，构造函数的自动调用时一个令人头疼的问题。c++17引入继承与改写构造的用法。

例一

struct B1
{
    B1(int) { std::cout << "B1" << std::endl; }
};

struct D1 : B1 {
    using B1::B1;//表示继承B1的构造函数
};

int main() {
    D1 d1(0);    //正确，委托基类构造函数进行初始化，调用B1::B1(int)
    return 0;
}

例二

struct B1
{
    B1(int) { std::cout << "B1" << std::endl; }
};

struct B2
{
    B2(int) { std::cout << "B2" << std::endl; }
};
struct D1 : B1, B2 {
    using B1::B1;//表示继承B1的构造函数
    using B2::B2;//表示继承B2的构造函数
};
struct D2 : B1, B2
{
    using B1::B1;
    using B2::B2;
    //正确，D2::D2(int)隐藏了B1::B1(int)和B2::B2(int)。另外由于B1和B2没有默认的构造函数，因此必须显式调用B1和B2的构造函数
    D2(int) : B1(1), B2(0)
    { std::cout << "D2" << std::endl; }
};

struct D3 : B1
{
    using B1::B1;
};
D3 d3(0);//正确，继承B1的构造函数，即利用B1的构造函数来初始化，输出B1

int main() {
    D2 d(100);//编译通过，输出B1   B2   D2
    return 0;
}

16）内联变量

参见1.5

17）用auto作为非类型模板参数

当模板参数作为非类型时，可用auto自动推导类型。

template<auto T>
void foo()
{
    cout<<T<<endl;
}
int main() {
    foo<100>();//输出100
    foo<int>(); //error: no matching function for call to 'foo<int>()'
    return 0;
}

3 宏

1）__has_include

判断有没有包含某文件。

int main() {

    #if __has_include(<vector>)
     std::cout <<"<vector> has included"<<std::endl;
    #endif
    #if __has_include("istream")
        std::cout << "iostream has included" << std::endl;
    #endif

    return 0;
}

4 属性

1）fallthrough

用于switch语句块内，表示会执行下一个case或default。

 int ok1, ok2;
    switch (0)
    {
        case 0:
        ok1 = 3;
        [[fallthrough]];
        case 1:
        ok2 = 1;
        [[fallthrough]];
    }

2）nodiscard

可用于类声明、函数声明、枚举声明中，表示函数的返回值没有被接收，再编译时会出现警告。

[[nodiscard]] class A {}; //该属性在这其实没用
[[nodiscard]] enum class B {}; //该属性在这其实没用
class C {};

[[nodiscard]] int foo()
{ return 10; }

[[nodiscard]] A func1() { return A(); }
[[nodiscard]] B func2() { return B(); }
[[nodiscard]] C func3() { return C(); }

int main()
{
    foo();//warning: ignoring return value
    func1();//warning: ignoring return value
    func2();//warning: ignoring return value
    func3();//warning: ignoring return value
    return 0;
}

3）mybe_unused

可用于类、typedef、变量、非静态数据成员、函数、枚举或枚举值中。用于抑制编译器对没用实体的警告。即加上该属性后，对某一实体不会发出“没有用”的警告。

[[maybe_unused]] class A {};
[[maybe_unused]] enum B {};
[[maybe_unused]] int C;
[[maybe_unused]] void fun(){};