lvalue-to-rvalue

问题 The code here test for lvalue or rvalue after a type cast: #include <stdio.h> template <typename T> T const f1(T const &t) { printf("T const \n"); return t; } template <typename T> T f1(T &t) { printf("T\n"); return t; } struct KK { int a; }; int main() { KK kk; kk.a=0; int ii; f1(kk); f1((KK)kk); f1(ii); f1((int)ii); return 0; } In gcc link the result is like this indicating rvalue resulted after a type cast: T T const T T const But in VC++2010, this is the result indicating rvalue only if

问题 The code here test for lvalue or rvalue after a type cast: #include <stdio.h> template <typename T> T const f1(T const &t) { printf("T const \n"); return t; } template <typename T> T f1(T &t) { printf("T\n"); return t; } struct KK { int a; }; int main() { KK kk; kk.a=0; int ii; f1(kk); f1((KK)kk); f1(ii); f1((int)ii); return 0; } In gcc link the result is like this indicating rvalue resulted after a type cast: T T const T T const But in VC++2010, this is the result indicating rvalue only if

问题 The question related to this one. By tracing slt_pair. h and move. h , it's seems that the difference between Clang and G++ is internally. I have tried to simulate the assignment of the object (pair.first) as same as the implementation of std_pair.h , the output is same as Clang output it's reasonable output, but why when using pairs it's changes. #include <iostream> struct Foo { Foo() { std::cout << "default" << std::endl; } Foo(Foo& f2) { std::cout << "non-const" << std::endl; } Foo(const

问题 The following function returns an rvalue: int foo() { int x = 42; return x; // x is converted to prvalue } Clang's AST also shows the conversion: `-FunctionDecl <line:1:1, line:5:1> line:1:5 foo 'int ()' `-CompoundStmt <line:2:1, line:5:1> |-DeclStmt <line:3:5, col:15> | `-VarDecl <col:5, col:13> col:9 used x 'int' cinit | `-IntegerLiteral <col:13> 'int' 42 `-ReturnStmt <line:4:5, col:12> `-ImplicitCastExpr <col:12> 'int' <LValueToRValue> ^^^^^^^^^^^^^^ `-DeclRefExpr <col:12> 'int' lvalue Var

问题 The following function returns an rvalue: int foo() { int x = 42; return x; // x is converted to prvalue } Clang's AST also shows the conversion: `-FunctionDecl <line:1:1, line:5:1> line:1:5 foo 'int ()' `-CompoundStmt <line:2:1, line:5:1> |-DeclStmt <line:3:5, col:15> | `-VarDecl <col:5, col:13> col:9 used x 'int' cinit | `-IntegerLiteral <col:13> 'int' 42 `-ReturnStmt <line:4:5, col:12> `-ImplicitCastExpr <col:12> 'int' <LValueToRValue> ^^^^^^^^^^^^^^ `-DeclRefExpr <col:12> 'int' lvalue Var

问题 I asked this question: static_assert of const Variable And apparently it comes down to the question does a floating point lvalue get converted to an rvalue for the purposes of comparison? So in this code does an lvalue-to-rvalue conversion occur? const float foo = 13.0F; static_assert(foo > 0.0F, "foo must be greater than 0."); 回答1: Yes, it is performed. Basically, it's all because 3.0 > 1.2 is a well-formed expression, that contains nothing but prvalues for operands. First, [expr]/9 states

问题 I suppose when a universal reference parameter is matched with an rvalue reference argument, an rvalue reference argument is returned. However, my testing shows that the rvalue reference is turned into a lvalue reference by the universal reference function template. Why is it so? #include <iostream> #include <type_traits> using namespace std; template <typename T> T f1(T&&t) { //<-----this is a universal reference cout << "is_lvalue reference:" << is_lvalue_reference<T>::value << endl; cout <

问题 In the following code, I'm not able to pass a temporary object as argument to the printAge function: struct Person { int age; Person(int _age): age(_age) {} }; void printAge(Person &person) { cout << "Age: " << person.age << endl; } int main () { Person p(50); printAge(Person(50)); // fails! printAge(p); return 0; } The error I get is: error: invalid initialization of non-const reference of type ‘Person&’ from an rvalue of type ‘Person’ I realize that this is something to do with passing an

问题 C++03 §4.2 N°1: An lvalue or rvalue of type “array of N T” or “array of unknown bound of T” can be converted to an rvalue of type “pointer to T.” The result is a pointer to the first element of the array. What has been confusing in this statement for a long time for me was that I didn't quite understand what an rvalue of array type would mean. That is, I couldn't come up with an expression whose type were an array and the result were an rvalue. I read this thread, which basically asks the

问题 I've been reading quite many on the Internet and it seems that many people mentioned the following rules (but i couldn't find it in the standard), The addition operator + (and all other binary operators) requires both operands to be rvalue, and the result is rvalue. And so on.. I checked the C++ standard, and it clearly states that (clause 3.10/2), Whenever a glvalue appears in a context where a prvalue is expected, the glvalue is converted to a prvalue (clause 5/9), Whenever a glvalue