The motivation for these two future types goes back to move semantics, move-only types, and the new C++11 feature to return move-only types from ordinary functions. In C++98/03, if you wanted to return a type from a factory function: A make_A() { A a; // … return a; } then A had to be CopyConstructible. … Read more
Unfortunately, you can’t put the increment into the range based for loop. However, in your specific case – as std::vector stores its elements contigously in memory – you can simulate option 2 by falling back to pointers (thanks to @M.M and @Jarod42 for corrections and improvements): for ( const int& val : v ) { … Read more
Code from “Olaf Dietsche” USE ATOMIC real 0m1.958s user 0m1.957s sys 0m0.000s USE VOLATILE real 0m1.966s user 0m1.953s sys 0m0.010s IF YOU ARE USING GCC SMALLER 4.7 http://gcc.gnu.org/gcc-4.7/changes.html Support for atomic operations specifying the C++11/C11 memory model has been added. These new __atomic routines replace the existing __sync built-in routines. Atomic support is also available … Read more
You aren’t explicitly following the “rule of three” (or is it five these days?). GCC will attempt to generate a copy constructor of UserQueues since you did not explicitly = delete; the copy constructor. When it does that, it will attempt to copy your std::vector<JobDeque>, but since that contains move-only std::unique_ptr‘s, it will fail to … Read more
You can’t put an override specifier when defining the function outside the class’s member specification. The language doesn’t allow it, and a compiler will complain. So there’s really only one option. Beyond that, this option also makes more sense. When declaring the function you are expressing an intent to override it. So putting override there … Read more
Is there a better way? YES C++11 delivers a new feature called delegating constructors which deals with this situation very gracefully. But it is a bit subtle. The problem with throwing exceptions in constructors is to realize that the destructor of the object you’re constructing doesn’t run until the constructor is complete. Though the destructors … Read more
Object slicing happens here. The point is given f = *p;, p is of type std::shared_ptr<Foo>, then the type of *p is Foo& (instead of Bar&). Even the assignment operator of std::function takes argument by reference, but 4) Sets the target of *this to the callable f, as if by executing function(std::forward<F>(f)).swap(*this);. Note that the … Read more
Because std::array<T, N> is an aggregate, it can be initialized as a constexpr if and only if the underlying type T has a constexpr constructor (when presented with each initializer you provide).
Different alternatives It is possible. There are several alternative approaches to your problem. Each one has different advantages and drawbacks (I will explain each one): Create an interface and have a template class which implements this interface for different types. It should support cloning. Use boost::variant and visitation. Blending static and dynamic polymorphism For the … Read more
A move constructor is called: when an object initializer is std::move(something) when an object initializer is std::forward<T>(something) and T is not an lvalue reference type (useful in template programming for “perfect forwarding”) when an object initializer is a temporary and the compiler doesn’t eliminate the copy/move entirely when returning a function-local class object by value … Read more