decltype can return the declared type of an entity (hence the name), but can also be used to query the type of an expression. However, in the latter case the resulting type is ‘adjusted’ according to the value category of that expression: an lvalue expression results in an lvalue reference type, an xvalue in an … Read more
This feature is called structured bindings in C++17. Very welcome addition! Sample usage: #include <iostream> #include <tuple> int main() { auto tuple = std::make_tuple(1, ‘a’, 2.3); // unpack the tuple into individual variables declared at the call site auto [ i, c, d ] = tuple; std::cout << “i=” << i << ” c=” << … Read more
The problem is your lambda. It doesn’t do what you think it does: function<const A&(const A& r)> foo1 = [](const A& r) { // ~~~~~~ return r; }; Note that there’s no trailing return type. That means that it’s automatically deduced. Deduction never gives you a reference type, so this lambda returns an A, not … Read more
Actually, the code for pairs is exactly the same, since std::tuple has operator = with std::pair as an argument. num_letter = std::make_pair(10, ‘a’); std::tie(num, letter) = num_letter;
Just read down below: During overload resolution, non-static cv-qualified member function of class X is treated as a function that takes an implicit parameter of type lvalue reference to cv-qualified X if it has no ref-qualifiers or if it has the lvalue ref-qualifier. Otherwise (if it has rvalue ref-qualifier), it is treated as a function … Read more
The difference between a captured argument and a passing argument could be seen with an analogy. Consider the following function object: struct Capture { int &i; int const j; public: Capture(int &_i, int &_j) : i(_i), j(_j) {} int operator()(int const a, int const b) { i *= j; return a * b; } }; … Read more
No, you (currently) cannot. The standard way of doing this is by creating “make_like” function (such as make_pair, make_optional …): template<typename F, typename… Args> A<std::decay_t<F>> make_A (F &&f, Args&&… args) { return {std::forward<F>(f), std::forward<Args>(args)…}; } C++17 will introduce template argument deduction for class which will allow you to do exactly what you want (see also … Read more
Yes, this is perfectly safe to swap vectors of the same type. Vector under the hood is just a few pointers pointing to the data the vector uses and “end” of the sequence. When you call swap you just exchange those pointers between the vectors. You don’t need to worry that the vectors are the … Read more
There is a manipulator to disable the whitespace skipping behavior: stream >> std::noskipws;
setw is going to set the width of the entire formatted output, including the displayed base, which is why you’re not seeing the leading 0. Also, there’s no way to make the base be displayed in lowercase if you use std::showbase along with std::uppercase. The solution is to insert the base manually, and then apply … Read more