The first chapter, Deducing Types, consists of four items that prepare a good ground for understanding the 2nd and 5th chapters about auto and move semantics, respectively.

The second chapter goes deeper into the auto, suggesting when to and not to use it. After C++17 there are even more ways and places to use auto, and if you think “… that’s fine, I’ll just wait for the next book from Meyers, Effective Moderner C++…”, don’t get your hopes high.

The third chapter, Moving to Modern C++, is the biggest chapter full of classic Meyers items, mostly about the new features of the language.

The fourth chapter is about the new Smart Pointers. For those who had used smart pointers, this chapter won’t be a discovery. As for others, if you had to use auto_ptr , I’m sorry for you. But good news, it’s over. Happy reading this chapter. And of course, it’s important and helpful for those who are completely new to the smart pointers.

The fifth chapter, Rvalue References, Move semantics and Perfect Forwarding, is of the highest importance. This has become one of the cornerstones of the language. You can’t choose whether or not to use it: it’s inevitable. Once you’re done with this chapter, try to answer the following questions:

What is move semantics? (Hint: most of the answers start like “Move semantics is… ehm… for example, you have a class…”. This is not an answer, don’t do that.

When do I implement a move constructor/assignment and/or copy constructor/assignment?

When do I implement a move constructor/assignment only ? What such classes are there in STL?

? What such classes are there in STL? What is considered a valid move constructor/assignment? Write a move for this class:

class VecOfInts

{

private:

int* m_data;

int m_size;

int m_capacity; public:

VecOfInts(VecOfInts&& rhs)

{

// your implementation here

} VecOfInts& operator=(VecOfInts&& rhs)

{

// your implementation here

} };

Be careful what you do with ‘rhs’.

These are the questions you must answer before going to an interview. There might also be questions about forwarding, which this chapter dives very deep into.

The next sixth chapter is about Lambda Expressions. This new feature will require some practice to get used to: it’s a new syntax. It’s just a syntactic sugar though, a faster and nicer way to define and instantiate functors. Frequent STL users will love it.

The seventh chapter is about The Concurrency API. No doubt this was a huge addition to the language. This chapter is especially helpful for people who’ve done concurrency in C++ before, with external libraries, people who know the theory behind the concurrency and multithreading. If you’re not one of them, I’d highly suggest reading at least the first chapter of this other book and get back to this.

Finally, the last small chapter called Tweaks comprises two items only, the last two tips from Meyers.