rvalue

问题 I've been studying rvalue references (a new concept for me), and am puzzled by a warning I receive in the following class function... string&& Sampler::Serial() const { stringstream ss; . . [assemble a string value using data members] . return ss.str(); } This compiles successfully, but with the following warning... ..\Metrics\Sampler.cpp:71:16: warning: returning reference to temporary [-Wreturn-local-addr] return ss.str(); ^ I'm fully aware that I'm returning a temporary, as evidenced by

问题 string three() { return “kittens”; } const string four() { return “are an essential part of a healthy diet”; } According to this article, the first line is a modifiable rvalue while the second is a const rvalue. Can anyone explain what this means? 回答1: The return values of your function are copied using std::string's copy constructor. You can see that if you step through your program execution with a debugger. As the conments say, it's quite self explantory. The first value will be editable

问题 I wonder if there is any way to differentiate the function calls (with arrays as parameters) shown in the following code: #include <cstring> #include <iostream> template <size_t Size> void foo_array( const char (&data)[Size] ) { std::cout << "named\n"; } template <size_t Size> void foo_array( char (&&data)[Size] ) //rvalue of arrays? { std::cout << "temporary\n"; } struct A {}; void foo( const A& a ) { std::cout << "named\n"; } void foo( A&& a ) { std::cout << "temporary\n"; } int main( /*

问题 #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

问题 int x = 12; 12 is said to be integer literal, and therefore can't be used in the LValue. How does the compiler allocate memory to a literals? What is the scope of a literals? Why can't we get its address with an &12 in its scope? 回答1: OK Bad example in the question. But the question is still valid: Lets try: Foo getFoo() {return Foo();} int func() { getFoo().bar(); // Creates temporary. // before this comment it is also destroyed. // But it lives for the whole expression above // So you can

问题 Why does this code not compile? #include <sstream> void f(std::stringstream) { } int main() { f(std::stringstream{}); } I get this error: error: use of deleted function ‘std::basic_stringstream<char>::basic_stringstream(const std::basic_stringstream<char>&)’ f(std::stringstream{}); ^ If I replace std::stringstream with another type that's noncopyable it works fine. Shouldn't this use stringstream 's move constructor? 回答1: The missing move constructor for stringstream is a known missing

问题 Trying to learn lvalues , rvalues and memory allocation for them. So with a lot of learning materials there is a bit of chaos. An rvalue is a value that needs to exist only in bounds of a expression where it was created (until C++11 at least). So it has an address and block of memory that it occupies. But by definition we cannot get an address of rvalue , because it is a temporary object in contrast to an lvalue . But even before C++11 we were able to get an address of rvalue by returning it

问题 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