In general, the new keyword auto in C++11 indicates that the type of the expression (in this case the return type of a function) should be inferred from the result of the expression, in this case, what occurs after the ->. Without it, the function would have no type (thus not being a function), and … Read more
Yes. See [class.copy] p32 When the criteria for elision of a copy operation are met or would be met save for the fact that the source object is a function parameter, and the object to be copied is designated by an lvalue, overload resolution to select the constructor for the copy is first performed as … Read more
The constructor needs access to the deleter in just the same way the destructor does: exception safety requires that the constructor be able to roll-back initialisation of all the members in the case that your constructor’s body throws: [C++14: 12.6.2/10]: In a non-delegating constructor, the destructor for each potentially constructed subobject of class type is … Read more
That’s a bug, possibly an incomplete port of some library code to cygwin (it’s a cplusplus11 feature) – some stuff has to be changed after all. Make sure to report it. The solution is easy of course: #include <cstdlib> strtol(s.c_str(),0,10); www.cplusplus.com/…/strtol A similar mingw bug is mentioned also here std::stoi doesn’t exist in g++ 4.6.1 … Read more
Because it never happens in a correct program, and making a check for something that never happens is wasteful (and to make that check it needs to store the owning thread ID, which is also wasteful). Note that it being undefined allows debug implementations to throw an exception, for example, while still allowing release implementations … Read more
There is a better way in C++0x for this class X: public Super { using Super::Super; }; If you declare a perfect-forwarding template, your type will behave badly in overload resolution. Imagine your base class is convertible from int and there exist two functions to print out classes class Base { public: Base(int n); }; … Read more
To the best of my knowledge, MinGW does not support yet the new c++0x concurrency features (as of GCC 4.5). I remember reading a mailing list exchange in which it was pointed out that in MinGW the following ifdef from the thread header is not satisfied: #if defined(_GLIBCXX_HAS_GTHREADS) I guess this is somehow related to … Read more
I always remember lvalue as a value that has a name or can be addressed. Since x has a name, it is passed as an lvalue. The purpose of reference to rvalue is to allow the function to completely clobber value in any way it sees fit. If we pass x by reference as in … Read more
I know I’m late, but this comes up when searching for “weak_ptr thread”, and Casey’s answer just isn’t the whole truth. Both shared_ptr and weak_ptr can be used from threads without further synchronization. For shared_ptr, there’s a lot of documentation (e.g. on cppreference.com or on stackoverflow). You can safely access shared_ptr‘s that point to the … Read more
Something along these lines, perhaps (untested): template <typename F> class Composer { int n_; F f_; public: Composer(int n, F f) : n_(n), f_(f) {} template <typename T> T operator()(T x) const { int n = n_; while (n–) { x = f_(x); } return x; } }; template <int N, typename F> Composer<F> compose(F … Read more