What are the new features of c++17

c 17 new features include: 1. Changes to the rules for auto expression derivation; 2. Lambda expressions can capture "*this"; 3. New inline variables, which can directly define global variables In the header file; 4. Support initialization statements in conditional expressions; 5. Direct list initialization of enumerations, etc.

The operating environment of this tutorial: Windows 7 system, C 17 version, Dell G3 computer.

Related recommendations: "C Video Tutorial"

New features in C 17

1. auto keyword

Starting from c 11, the auto keyword can deduce the type of a variable through an initializer. In C 14, the ability of the auto keyword is further improved, and the return type of the function can be deduced through the return statement. Using the auto keyword can improve coding efficiency and simplify the reconstruction process. However, auto derivation in C 11 often results in different results than expected.

In order to support unified initialization in c 11, a new unified initialization syntax is introduced, as shown below.

// c++11
auto x3{ 1, 2 }; // std::initializer_list<int>
auto x4 = { 3 }; // decltype(x4) is std::initializer_list<int>
auto x5{ 3 };    // std::initializer_list<int>

For variables initialized in these three ways, the final type derivation result is std::initializer_list, not the int we think. This is because when the expression used to declare a variable auto is enclosed in {}, the deduced type becomes std::initializer_list.

In C 17, the rules for auto expression derivation have been changed

// c++17
auto x3{ 1, 2 }; // error: not a single element
auto x4 = { 3 }; // decltype(x4) is std::initializer_list<int>
auto x5{ 3 };    // decltype(x5) is int

Comparison found that auto x5{3}, will directly derive the variable into x5, while x3{1, 2} This method will also fail to compile. The rules of auto derivation become more intuitive.

2. Lambda expression

lambda was also introduced in C 11. In C 11, lambda expressions can only capture this, which is the current object. A read-only reference. In C 17, you can capture *this, which is a copy of the current object. Capturing a copy of the current object can ensure that after the current object is released, the lambda expression can safely call the variables and methods in this.

3. Inline variables

Inline variables, inline variables allow variables to be defined more than once. Before C 17, when we defined global variables, we always needed to define the variable in the cpp file, and then use the extern keyword to tell the compiler that the variable has been defined elsewhere. After the inline variable appears, we can directly define the global variable in the header file without worrying about the redefine error message.

4. Initialization statements are supported in conditional expressions

c 17 supports initialization in if or switch statements. The emergence of this capability can make the code more concise .

// c++17之前
map<int, string> c = {{1,"a"}};
{
    auto res = c.insert(make_pair(2, "b"));
    if(!res.second) {
        cout << "key 1 exist" << endl;
    } else {
        cout << "insert success, value:" << res.first->second << endl;
    }
}

In the above piece of code, since res is a temporary variable and we don’t want to affect the subsequent code, we use a pair of curly braces to limit its scope. But if you use the syntax of c 17 and initialize res in the if condition, the code will appear more concise

// c++17
map<int, string> c = {{1,"a"}};
if(auto res = c.insert(make_pair(2, "b")); !res.second ) {
    cout << "key 1 exist" << endl;
} else {
    cout << "insert success, value:" << res.first->second << endl;
}

The standard library of c 17 has also been expanded, and the following data types have been added:

1. std::variant

std::variant is a type-safe union and an enhanced version of union. Variant supports more complex data types, such as map , string, etc.

2. std::optional

std::optional represents a possible value. When we create an object through a function, we usually use the function to return the error code and return the object itself through the parameters. If you return the created instance through optional, it will become more intuitive.

std::optional provides the following methods:

has_value()   // 检查对象是否有值
value()       // 返回对象的值，值不存在时则抛出 std::bad_optional_access 异常
value_or()    // 值存在时返回值，不存在时返回默认值

3. std::any

A type-safe container that can save any value

4. std::string_view

string_view I first used the boost version , string_view in c17 is similar to boost. string_view can be understood as a read-only reference to the original string. string_view itself does not apply for additional memory to store the original string data, but only saves the original string address and length. In many cases, we are only processing strings temporarily and do not need a copy of the original string. Using string_view can reduce unnecessary memory copies and improve program performance. Compared to using string pointers, string_view provides better encapsulation.

It should be noted that since string_view does not have ownership of the original string, you must pay attention to the life cycle of the original string when using string_view. When the original string has been destroyed, string_view can no longer be called.

Other features:

In addition, C 17 also adds some other features, which are not listed one by one in the article.

• bool expression cannot be used, – these two increment (decrease) operators are no longer used

• #Exception in c 17 has become a type Part of the system,

• Direct list initialization of the enumeration

• Structured binding

• constexpr if expression

• map supports merge and extract

For more programming-related knowledge, please visit: Programming Learning! !

The above is the detailed content of What are the new features of c++17. For more information, please follow other related articles on the PHP Chinese website!