You don’t have to specify an initializer for mySecondVar at the point of declaration. Nor is the initializer required to be constexpr itself. This means that if we attempt to define myFirstVar like this: class MyClass { static constexpr int myFirstVar; }; int MyClass::myFirstVar = 1; Or like this: #include <cstdlib> class MyClass { static … Read more
It limits the scope of length to the if alone. So you get the same benefits we originally got when we were allowed to write for(int i = 0; i < … ; ++i) { // … } Instead of the variable leaking int i; for(i = 0; i < … ; ++i) { // … Read more
According to GCC reference, C17 is actually a bug-fix version of the C11 standard with DR resolutions integrated. C17, a bug-fix version of the C11 standard with DR [Defect Report] resolutions integrated, will soon go to ballot. This patch adds corresponding options -std=c17, -std=gnu17 (new default version, replacing -std=gnu11 as the default), -std=iso9899:2017. As a … Read more
The discussed alternatives are clear but I feel that a code example is needed. Given that there will not be a language substitute and without relying on boost or on your own version of iterator base class, the following code that uses std::iterator will be fixed to the code underneath. With std::iterator template<long FROM, long … Read more
Another alternative is to use an std::tie: int b, c; std::tie(std::ignore, b, c) = foo(); Edit As mentioned in the comments, there are some issues with this approach: No type inference possible The objects must be constructed before, so unless the default constructors are trivial, it’s not a good alternative.
The only difference is that if constexpr is evaluated at compile time, whereas if is not. This means that branches can be rejected at compile time, and thus will never get compiled. Imagine you have a function, length, that returns the length of a number, or the length of a type that has a .length() … Read more
No. Access to volatile objects is considered observable behavior, exactly as I/O, with no particular distinction between locals and globals. The least requirements on a conforming implementation are: Access to volatile objects are evaluated strictly according to the rules of the abstract machine. […] These collectively are referred to as the observable behavior of the … Read more
Is this interpretation of this modification of the standard right or are there other rules that compensate the deletion of this cited sentence? Yes, this interpretation is correct. A pointer past the end isn’t simply convertible to another pointer value that happens to point to that address. The new [basic.compound]/3 says: Every value of pointer … Read more
std::visit seems to lack some optimizations yet on some implementations. That being said there’s a central point thats not very well seen in this lab-like setup – which is that variant based design is stack based vs. the virtual inheritance pattern which will naturally gravitate towards being heap based. In a real world scenario this … Read more
It seems you have to include <filesystem> like this: #include <experimental/filesystem> Don’t forget to add -lstdc++fs as a GCC flag! Here is the proof: Coliru If that doesn’t work, then that probably means that you don’t have filesystem in your configuration. Also, as @MartinR. pointed out, the experimental is no longer needed in GCC 8+.