lvalue

问题 This question already has answers here : Closed 7 years ago . Possible Duplicate: Is array name a pointer in C? Suppose I have a char array say arr and arr will represent the address of first element so arr++ should be perfectly legal then why compiler says 'lvalue required'. Also if I do: arr=arr+1 then why it is invalid conversion. I am just increasing pointer by one. Compiler tells that on LHS the operand type is char[4] but on RHS it is char *. main() { char arr[]={'a','b','c','d'}; for(

问题 After reading the chapter about structures in the K&R book I decided to make some tests to understand them better, so I wrote this piece of code: #include <stdio.h> #include <string.h> struct test func(char *c); struct test { int i ; int j ; char x[20]; }; main(void) { char c[20]; struct {int i ; int j ; char x[20];} a = {5 , 7 , "someString"} , b; c = func("Another string").x; printf("%s\n" , c); } struct test func(char *c) { struct test temp; strcpy(temp.x , c); return temp; } My question

问题 I am trying to return a block of a matrix as an lvalue of a function. Let's say my function looks like this: Block<Derived> getBlock(MatrixXd & m, int i, int j, int row, int column) { return m.block(i,j,row,column); } As it turns out, it seems that C++ compiler understands that block() operator gives only temporary value and so returning it as an lvalue is prohibited by the compiler. However, in Eigen documentation there is some example that we can use Eigen as an lvalue (http://eigen

问题 #include<iostream> using namespace std; int fun(int &x) { return x; } int main() { cout << fun(10); return 0; } Can anyone explain the reason of the error ? Thanks 回答1: 10 is a constant, so you can't pass a reference to it, simply because the whole concept of changing a constant is bizarre. References were introduced to solve one of the thorny problems in C (and earlier C++), the fact that everything is passed by value and, if you want to have a change reflected back to the caller, you have

问题 This is a followup from function template does not recognize lvalue Lets play with the following code: #include <iostream> template <class T> void func(T&&) { std::cout<<"in rvalue\n"; } template <class T> void func(const T&) { std::cout<<"in lvalue\n"; } int main() { double n=3; func<double>(n); func(n); } It prints: in lvalue in rvalue I don't understand what's happening in the second call. How the compiler resolve the template parameter ? Why isn't there any ambiguity ? 回答1: When you say

问题 In C, is there a way to identify the rvalues and lvalues ? Some of them are easy to identity say, in an assignment, the left value is lvalue and the value in the right is rvalue. But other scenarios, identification with such a rule is difficult. For example : *p++ and i++ (where p is a pointer to integer and i is an integer) - how to identify whether it is an rvalue or lvalue ? The context is ++*p++ works while ++i++ does not since i++ is an rvalue (as told by serious guys). How to identify

问题 Why myint++++ compiles fine with VS2008 compiler and gcc 3.42 compiler ?? I was expecting compiler say need lvalue, example see below. struct MyInt { MyInt(int i):m_i(i){} MyInt& operator++() //return reference, return a lvalue { m_i += 1; return *this; } //operator++ need it's operand to be a modifiable lvalue MyInt operator++(int)//return a copy, return a rvalue { MyInt tem(*this); ++(*this); return tem; } int m_i; }; int main() { //control: the buildin type int int i(0); ++++i; //compile

问题 I made a class Array which holds an integer array. From the main function, I'm trying to get an element of the array in Array using [ ] as we do for arrays declared in main. I overloaded the operator [ ] as in the following code; the first function returns an lvalue and the second an rvalue (Constructors and other member functions are not shown.) #include <iostream> using namespace std; class Array { public: int& operator[] (const int index) { return a[index]; } int operator[] (const int

问题 This looks a very basic topic but very important to me. The following example shows that the address of a reference variable is equal to the address of the original variable. I know this is what we can expect from the concept of C/C++. However, is it always guaranteed that these addresses are equal under any circumstance? #include <iostream> #include <vector> #include <string> class Point { public: double x,y; }; void func(Point &p) { std::cout<<"&p="<<&p<<std::endl; } int main() { std:

问题 I just started learning about rvalue references in c++11 by reading this page, but I got stuck into the very first page. Here is the code I took from that page. int& foo(); foo() = 42; // ok, foo() is an lvalue int* p1 = &foo(); // ok, foo() is an lvalue int foobar(); j = foobar(); // ok, foobar() is an rvalue int* p2 = &foobar(); // error, cannot take the address of an rvalue why is foo() an lvalue? is it because foo() returns int& which is basically an lvalue? why is foobar() an rvalue? is