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.
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.
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++.
Its going to be added to the language MAYBE.
One of the problems with the first approach was, that it used {}, but did not introduce scope. A serious wtf in any c-like language.
Well, of course accessing the value of fh after foo would be fatal.
But how would you then sort a container of moveable-only objects?
An object should be accessible for reassigning a value after its move, as its often needed for algorithms, thats exactly why the C++ Standard mandates this. Move does really only make sense if the class holds a moveable allocation, such as a container, array etc., which makes copying expensive.
ACCU - https://conference.accu.org/site/index.html
Meeting C++ - https://meetingcpp.com (9-11. Nov) not yet announced
ADC - https://adcpp.de/2017/
code::dive (not yet announced) https://codedive.pl/pl/index/
NDC Oslo - https://ndcoslo.com/
Audio Developer Conference:(not yet announced) https://www.juce.com/adc-2016
emBO++ (embedded C++)- https://www.embo.io/