Effective Modern C++

Synopsis

Coming to grips with C++11 and C++14 is more than a matter of familiarizing yourself with the features they introduce (e.g., auto type declarations, move semantics, lambda expressions, and concurrency support). The challenge is learning to use those features effectively-so that your software is correct, efficient, maintainable, and portable. That's where this practical book comes in. It describes how to write truly great software using C++11 and C++14-i.e. using modern C++.

Topics include:

• The pros and cons of braced initialization, noexcept specifications, perfect forwarding, and smart pointer make functions
• The relationships among std::move, std::forward, rvalue references, and universal references
• Techniques for writing clear, correct, effective lambda expressions
• How std::atomic differs from volatile, how each should be used, and how they relate to C++'s concurrency API
• How best practices in "old" C++ programming (i.e., C++98) require revision for software development in modern C++

Effective Modern C++ follows the proven guideline-based, example-driven format of Scott Meyers' earlier books, but covers entirely new material.

"After I learned the C++ basics, I then learned how to use C++ in production code from Meyer's series of Effective C++ books. Effective Modern C++ is the most important how-to book for advice on key guidelines, styles, and idioms to use modern C++ effectively and well. Don't own it yet? Buy this one. Now".

-- Herb Sutter, Chair of ISO C++ Standards Committee and C++ Software Architect at Microsoft

Summary

Chapter 1: Introduction to Modern C++

This chapter provides an overview of modern C++, including its key features and benefits. It introduces the concept of "resource acquisition is initialization" (RAII) and emphasizes the importance of memory management.

Real example:
A class that manages a file handle, automatically releasing it when the object goes out of scope:

```cpp
class FileHandle {
public:
FileHandle(const std::string& filename) {}
~FileHandle() {}
// Other file operations
};

int main() {
{
FileHandle handle("myfile.txt");
// Use the file handle
} // handle is automatically closed here
}
```

Chapter 2: Language Features

This chapter covers specific language features introduced in modern C++, such as lambdas, decltype, auto, and structured bindings. It also discusses the use of constexpr and inline functions for performance optimization.

Real example:
Using a lambda to sort a vector of strings by length:

```cpp
std::vector strings{"a", "bc", "def"};
std::sort(strings.begin(), strings.end(), [](const auto& a, const auto& b) {
return a.size() < b.size();
});
```

Chapter 3: Containers and Algorithms

This chapter explores the Standard Template Library (STL) containers and algorithms, including vectors, lists, maps, and sets. It highlights the use of iterators and range-based for loops for efficient iteration.

Real example:
Using a map to count the occurrences of words in a text file:

```cpp
std::map word_counts;
for (const auto& word : text) {
++word_counts[word];
}
```

Chapter 4: Memory Management

This chapter delves deeper into memory management in modern C++, emphasizing the use of smart pointers (e.g., unique_ptr and shared_ptr) to prevent memory leaks and double-frees. It also introduces the concepts of move semantics and perfect forwarding.

Real example:
Using a unique_ptr to manage a dynamically allocated object:

```cpp
std::unique_ptr object = std::make_unique();
```

Chapter 5: Concurrency

This chapter covers concurrency-related features in modern C++, including threads, locks, and atomic operations. It discusses techniques for synchronization and data sharing in concurrent programs.

Real example:
Using a thread pool to perform parallel tasks:

```cpp
std::vector threads;
for (const auto& task : tasks) {
threads.emplace_back([task]() {
// Perform the task
});
}
for (auto& thread : threads) {
thread.join();
}
```

Chapter 6: Metaprogramming

This chapter introduces advanced techniques for reflection and genericity in modern C++, including template metaprogramming and SFINAE (Substitution Failure Is Not An Error). It explores techniques for type introspection and compile-time computation.

Real example:
Using a template metafunction to calculate the factorial of a number at compile time:

```cpp
template
struct Factorial {
static constexpr int value = N * Factorial::value;
};
template <>
struct Factorial<0> {
static constexpr int value = 1;
};

int main() {
constexpr int result = Factorial<5>::value; // Calculates 5! at compile time
}
```