Other books I've been reading: _C++ 17 The Complete Guide_ by Josuttis _C++ 17 in Detail_ by Filipek

Lots of good blogs out there. Also the CPP Podcast. http://cppcast.com/

There are also a lot of great blogs covering new features. Also

Note: I do wish HN would adopt standard markdown

Aaand you've just learned all the formatting HN has :). That, and URLs automatically turn into clickable everywhere except the body of a self-submission (i.e. submitting a text instead of a link). Any other formatting here is just convention.

http://scottmeyers.blogspot.com/

https://github.com/AnthonyCalandra/modern-cpp-features/blob/...

If you already know the language flow control you don't need to read paragraphs of a book to relearn to how "think" in the language. You just need the "whats new" parts.

(I hear the compile times are the same though -.-)

Which probably means that someone who learned modern C++ will have significant difficulty with older C++.

Sometimes it makes me wonder if someone should just declare a subset of C++ as "good" and call it a new language.

The combination of "auto" (plus template type inference), ranged for-loops, initializer lists, structured bindings, lambdas and certain new standard library mechanisms (std::unique_ptr, std::variant, std::optional, std::move, etc.) together change the high-level expressiveness of the language, encoding a lot of common patterns and eliminating common, redundant code. For example:

  std::vector values = {1, 2, 3};
  for (auto v : values) { ... }

  for (auto &&[key, value] : mapOfStuff) { ... }

  struct Foo {
    Foo(std::initializer_list<int> values) { ... }
  }

  Foo f = {1, 2, 3};

  struct Person {
    string name
  }
  Person p = {.name = "bob"};

  getNumbers()
    | view::filter([](int a, int b) { return a > b; }
    | view::reverse()
    | view::take(10);

  template <typename T>
    T add100(T v) {
      // Compiler will fail on this line:
      return v + 100;  
    }

  auto n = add100("hello world");

  template <Incrementable T>
    T add100(T v) {
      return v + 100;
    }

  // Compiler fails on this line:
  auto n = add100("hello world");

Lastly, C++ designers seem to have thought a lot about safe memory semantics, and so there's a renewed focus on smart pointers (that actually work) together with move semantics and tightening of cop constructor semantics. The end result is that it's generally easier to work with RAII and avoid explicit heap allocation with the "new" keyword.