To me it sounds like someone messed up merging the previous standard with the new one. Previously the standard said this: (C++14 N4140, 7.1.6.4.7 [dcl.spec.auto]): When a […] return statement occurs in a function declared with a return type that contains a placeholder type, the deduced return type or variable type is determined from the … Read more
There are several approaches for detect and discard inclusion of the project, which has already be included in some other parts of the main project. Check project’s target existence The simplest pattern for single inclusion of subproject is checking existence of some subproject’s target: # When include ‘C’ subproject if(NOT TARGET library_C) add_subdirectory(C) endif() (Here … Read more
The standard allows for this behavior, although it doesn’t guarantee it. From 3.7.2/2 [basic.stc.thread]: A variable with thread storage duration shall be initialized before its first odr-use (3.2) and, if constructed, shall be destroyed on thread exit. It’s also possible that the objects are constructed at some other time (e.g. on program startup), as “before … Read more
Close the solution then go to the packages folder on your hard drive and delete all its contents. Open your application again in Visual Studio and it will automatically try to restore the packages. Clean the Solution and Build it.
A constexpr function does NOT have to be defined before its first use, however the result of any call made prior to definition is not a constant expression. Source: C++ Standard draft n4296, section 5.20: A conditional-expression e is a core constant expression unless the evaluation of e, following the rules of the abstract machine, … Read more
boost::variant will heap allocate in order to have part of itself be recursively defined as itself. (It will also heap allocate in a number of other situations, uncertain how many) std::variant will not. std::variant refuses to heap allocate. There is no way to actually have a structure containing a possible variant of itself without a … Read more
You are thinking in terms of sequential consistency, the strongest (and default) memory order. If this memory order is used, all accesses to atomic variables constitute a total order, and the assertion indeed cannot be triggered. However, in this program, a weaker memory order is used (release stores and acquire loads). This means, by definition … Read more
The transparent operator functors proposal is there as a way to have generalised functors that are located in <functional>. I personally believe the proposal itself has a very good example that would help illustrate the need for it. However I’ll go ahead and try to explain it as well. Suppose you have a function, a … Read more
It’s often used to realize static polymorphism. Use cases are: Policy-based design Curiously recurring template pattern Barton–Nackman trick In general you have the benefits from dynamic polymorphism, without the extra runtime costs of virtual functions. But it’s only useful if the concrete type can be determined at compile time.
One example of the difference is when you want (for whatever reason) to make an optional containing an optional: #include <optional> #include <type_traits> int main() { auto inner=std::make_optional(325); auto opt2=std::make_optional(inner); // makes std::optional<std::optional<int>> auto opt3=std::optional(inner); // just a copy of inner static_assert(std::is_same_v<decltype(opt2), std::optional<std::optional<int>>>); static_assert(std::is_same_v<decltype(opt3), std::optional<int>>); }