meetingcpp

boost::variant is 12 years old, the std::variant version is not based on the actual design nor is it a copy of the boost implementation.

The interface is very similar, but the implementation is ofc using C++17 and not C++03.

Whats holding you back then?

Eric Nieblers Range-v3 library is available:

https://github.com/ericniebler/range-v3/

Its not going to be (much) better in the standard...

Except that it would use real concepts then...

The very first link is a link to the previous part of the series.

Well, they have been accepted into the standard last week ;)

Well, there is progress on all features, yet nothing is ready to go into C++17. So either we get no new standard at all, or we get a Standard without the large features.

Also C++14 was a step forward, generic lambdas are a step forward (boost::hana is based on this, and brings though compile times down), I expect similar language features in C++17, that ease the programming and will bring new innovations to C++.

Your boost argument is only valid for library features. Modules or concepts can never be a part of boost in the way they are in the TS.

Well, boost::filesystem exists for ages...

No, that is not dropped, but it also is not contained in a TS yet, I'm not sure if it gets added to C++17.

There is a wording paper: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p005...

Not sure if Jacksonville will already give green light or if this will be decided later. Would be a good addition though.

If you can, go for C++14 directly, it offers improvements over C++11.

Language features that ease your daily working with C++11/14:

- Lambdas, especially when working with <algorithm>

- ranged for loop

- auto instead of typing long types

- variadic templates increase compilation speed over the previous macro based simulation of this feature.

- the basic support for multithreading which std::thread & co offer.

And also, as always in C++: you only pay for what you use. You still can write code in old styles pretty well with C++14, same will be true for coming standards.

Yes, that is correct. That is not possible, modules might offer things in this direction.

um, nope, not going to happen...

C++ did that in the 2000's, in that time there wasn't much news about standardization, because of this C++ was seen as legacy, people moved to other languages. The new languages such as Rust, Go etc. are also a result of this.

The C++ committee has now a process of ongoing standardization established, which will improve the language further, and make it easier and more efficient to write C++. Also, the standards are usually backward compatible for at least 2 standards. What gets removed is often obscure features like auto_ptr, random_shuffle etc. which are superseeded by better alternatives. Clang modernize can even get your code base automatically updated to a new standard.

I know, that some of you are left behind, as you are stuck with the traditional "almost never update the toolchain" model, but clang and other tools are such a leap forward, that this is not a model for the future anymore.

So, C++ ecosystem evolves to become better, and make you as a programmer more productive and lets you write easier and safer code.

Well, that has been done for decades. You just need to link your code with the correct libraries.

Its probably a bit easier with C as it has a common ABI, and C# as it only has one tool chain, and not multiple toolchains from multiple vendors like C++.

Modules will help here further.