Each element of the container is a map<K, V>::value_type, which is a typedef for std::pair<const K, V>. Consequently, in C++17 or higher, you can write for (auto& [key, value]: myMap) { std::cout << key << ” has value ” << value << std::endl; } or as for (const auto& [key, value]: myMap) { std::cout << … Read more
Flags (or compiler options) are nothing but ordinary command line arguments passed to the compiler executable. Assuming you are invoking g++ from the command line (terminal): $ g++ -std=c++11 your_file.cpp -o your_program or $ g++ -std=c++0x your_file.cpp -o your_program if the above doesn’t work.
I believe there is a difference. Let’s rename them so that we can talk about them more easily: const double PI1 = 3.141592653589793; constexpr double PI2 = 3.141592653589793; Both PI1 and PI2 are constant, meaning you can not modify them. However only PI2 is a compile-time constant. It shall be initialized at compile time. PI1 … Read more
C++11 added alias declarations, which are generalization of typedef, allowing templates: template <size_t N> using Vector = Matrix<N, 1>; The type Vector<3> is equivalent to Matrix<3, 1>. In C++03, the closest approximation was: template <size_t N> struct Vector { typedef Matrix<N, 1> type; }; Here, the type Vector<3>::type is equivalent to Matrix<3, 1>.
I understand the situation a bit better now (in no small amount due to the answers here!), so I thought I add a little write-up of my own. There are two distinct, though related, concepts in C++11: Asynchronous computation (a function that is called somewhere else), and concurrent execution (a thread, something that does work … Read more
is there some other clause in the language specification that this exploits? Yes, see 12.8 §34 and §35: When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object […] This elision of copy/move operations, called copy elision, is permitted […] in a return statement in a function … Read more
The difference is that you can lock and unlock a std::unique_lock. std::lock_guard will be locked only once on construction and unlocked on destruction. So for use case B you definitely need a std::unique_lock for the condition variable. In case A it depends whether you need to relock the guard. std::unique_lock has other features that allow … Read more
Here are the possible ways to take a unique pointer as an argument, as well as their associated meaning. (A) By Value Base(std::unique_ptr<Base> n) : next(std::move(n)) {} In order for the user to call this, they must do one of the following: Base newBase(std::move(nextBase)); Base fromTemp(std::unique_ptr<Base>(new Base(…)); To take a unique pointer by value means … Read more
First example std::vector<int> return_vector(void) { std::vector<int> tmp {1,2,3,4,5}; return tmp; } std::vector<int> &&rval_ref = return_vector(); The first example returns a temporary which is caught by rval_ref. That temporary will have its life extended beyond the rval_ref definition and you can use it as if you had caught it by value. This is very similar to … Read more
You have to understand the forwarding problem. You can read the entire problem in detail, but I’ll summarize. Basically, given the expression E(a, b, … , c), we want the expression f(a, b, … , c) to be equivalent. In C++03, this is impossible. There are many attempts, but they all fail in some regard. … Read more