C++ user group is a fairly large. From the advent of C++98 to the official finalization of C++11, it has accumulated over a decade. C++14/17 is an important complement and optimization for C++11, and C++20 brings this language to the door of modernization. The extended features of all these new standards are given to the C++ language. Infused with new vitality.

**Modern C++** (this book refers to C++11/14/17/20) introduces a lot of features into traditional C++, which makes the whole C++ become language that modernized. Modern C++ not only enhances the usability of the C++ language itself, but the modification of the `auto` keyword semantics gives us more confidence in manipulating extremely complex template types. At the same time, a lot of enhancements have been made to the language runtime. The emergence of Lambda expressions has made C++ have the "closure" feature of "anonymous functions", which is almost in modern programming languages ​​(such as Python/Swift/.. It has become commonplace, and the emergence of rvalue references has solved the problem of temporary object efficiency that C++ has long been criticized.

Before learning modern C++, let's take a look at the main features that have been deprecated since C++11:

- **The string literal constant is no longer allowed to be assigned to a `char *`. If you need to assign and initialize a `char *` with a string literal constant, you should use `const char *` or `auto`.**

```cpp

char *str = "hello world!"; // A deprecation warning will appear

```

all:

$(C) -c $(SOURCE_C)

$(CXX) $(SOURCE_CXX) $(OBJECTS_C) $(LDFLAGS_COMMON) -o $(TARGET)

clean:

rm -rf *.o $(TARGET)

```

In the above code, we can see that the `itr` variable is defined in the scope of

we can do this in if(or switch):

C++11 first binds the concept of the initialization list to the type

and calls it `std::initializer_list`,

allowing the constructor or other function to use the initialization list

a unified bridge between normal arrays and POD initialization methods,

such as:

Lambda expressions are one of the most important features in modern C++, and Lambda expressions actually provide a feature like anonymous functions.

So anonymous functions are almost standard on modern programming languages.

except that the function name of the general function is omitted.

The return value is in the form of a `->`

(we have already mentioned this in the tail return type earlier in the previous section).

it enhances the runtime capabilities of the C++ language.

This part of the content is also very important, so put it here for introduction.

std::string&& rv2 = lv1 + lv2; // legal, rvalue ref extend lifecycle

rv2 += "string"; // legal, non-const reference can be modified

reference(rv2); // output: lvalue

Programmers who have known Python should be aware of the concept of tuples. Looking at the containers in traditional C++, except for `std::pair`

But the flaw of `std::pair` is obvious, only two elements can be saved.

But not enough, because using `std::shared_ptr` still needs to be called with `new`, which makes the code a certain degree of asymmetry.

It can be locked by its member function `lock()`, and `unlock()` can be unlocked.

But in the process of actually writing the code, it is best not to directly call the member function,

Because calling member functions, you need to call `unlock()` at the exit of each critical section, and of course, exceptions.

#include <iostream>

For example, a thread may need to wait for a condition to be true to continue execution.

A dead wait loop can cause all other threads to fail to enter the critical section so that when the condition is true, a deadlock occurs.

Therefore, the `condition_variable` instance is created primarily to wake up the waiting thread and avoid deadlocks.

`notify_all()` is to notify all threads. Below is an example of a producer and consumer model:

}

But the actual situation is much more complicated than this, or the code itself is undefined behavior, because for `a` and `flag`, they are read and written in two parallel threads.

There has been competition. In addition, even if we ignore competing reading and writing, it is still possible to receive out-of-order execution of the CPU, and the impact of the compiler on the rearrangement of instructions.

Cause `a = 5` to occur after `flag = 1`. Thus `b` may output 0.

而通过其成员函数 `lock()` 可以进行上锁，`unlock()` 可以进行解锁。

但是在在实际编写代码的过程中，最好不去直接调用成员函数，

因为调用成员函数就需要在每个临界区的出口处调用 `unlock()`，当然，还包括异常。

RAII 在不失代码简洁性的同时，很好的保证了代码的异常安全性。

在 RAII 用法下，对于临界区的互斥量的创建只需要在作用域的开始部分，例如：

// p2 is empty, no prints

if(p2) p2->foo();

}

// p1 is not empty, prints

if (p1) p1->foo();

}

std::shared_ptr<B> pointer;

~A() {

}

};

class B {

std::shared_ptr<A> pointer;

~B() {

}

};

int main() {

{

std::unique_lock<std::mutex> lock(queue_mutex);

if(stop)

throw std::runtime_error("enqueue on stopped ThreadPool");