0

RValueはメモリの操作可能な領域ではないため、整数などのリテラルはRValueと見なされます。

  1. 定数はRValueを構成しますか？const int x = 0;少なくとも1回は操作可能です。
  2. 現在、コンパイラーによって作成された一時オブジェクトは、操作可能なメモリー領域がある場合でもRValuesです。どうしてこんなことに？
    「ユーザー」が変更できないので？これが理由ですか？

それで、「ユーザー」が操作できないメモリ領域はRValueと呼ばれますか？

4

7 に答える 7

4

Scalar rvalues are expressions that evaluate to scalar values like 42 or i + k (whereas scalar lvalues are expressions that evaluate to scalar objects like i or *int_ptr or numbers[0]).

rvalues of class type are expressions that evaluate to temporary objects. The most prominent example is the call of a function that returns a class object by value:

std::string foo()
{
    return "hello world";
}

Given the above function definition, the expression foo() is an rvalue. Note that I'm not talking about the result (which is a temporary object) but the expression foo() whose evaluation yields that result.

于 2011-12-21T06:55:43.830 に答える
3
  1. Do constants constitute RValues? const int x = 0; is maniputable at least one time.

In your declaration, x is neither an rvalue or lvalue, it is called a declarator-id. (See grammar of 8/4 in C++03) When it is used in a (sub-)expression it is a non-modifiable lvalue which can be initialized to any constant expression.

2.Now, the temporary objects created by the compiler are also RValues even when they have maniputable memory regions. Why is that so? Because they cannot be modified by "users"? Is this the reason?

Rvalue of a class type can either be modifiable or non-modifiable but rvalues of built-in types are always cv-unqualified.

§ 3.10/9 Class rvalues can have cv-qualified types; non-class rvalues always have cv-unqualified types.

Consider this example:

struct S {
     int x;
     void f(int s) { x = s; }
};

// ill-formed: Cannot assign to an rvalue of built-in type.
S().x = 42;

// Valid: A member function can be used to modify the referent of rvalue.
S().f(42);

The sub-expression S() creates an rvalue of class type whose lifetime is the end of ; full-expression.

于 2011-12-21T08:40:52.873 に答える
1

RValueは、メモリの操作可能な領域ではないものです。

右辺値は式であり、「もの」ではありません。

右辺値はオブジェクト（「メモリの操作可能な領域」）を参照できます。

したがって、整数などのリテラルはRValueと見なされます。

C ++はそのように定義されているため、リテラルは右辺値です（「考慮された」右辺値ではありません）。

定数はRValueを構成しますか？

const int x = 0;

実際には、は型xの変数const intです。

上記のの定義を考えるとx、式xは左辺値です。

現在、コンパイラによって作成された一時オブジェクトもRValuesです。

いいえ、右辺値は式であり、オブジェクトではありません。

操作可能なメモリ領域がある場合でも。どうしてこんなことに？

そうではありません。

「ユーザー」が変更できないので？これが理由ですか？

言語がこのように定義されているため、右辺値は右辺値です。

それで、「ユーザー」が操作できないメモリ領域はRValueと呼ばれますか？

いいえ、右辺値は式のみを指定し、メモリなどの実行時に存在するものは指定しません。

右辺値は、ユーザーが操作できる「メモリ領域」であるオブジェクトを参照する場合があります。

「ユーザー」が操作できないメモリ領域

ここで何を意味するのかは明確ではありません。読み取り専用メモリ、または他の何かを意味しますか？

于 2011-12-21T09:48:28.083 に答える
1

An lvalue refers to a memory location and we can take the address of that memory location using the & operator. An rvalue is an expression which is not an lvalue.

1. Do constants constitute RValues? const int x = 0; is maniputable at least one time.

No, because you an do this - const int *p = &x

于 2011-12-21T06:56:06.567 に答える
1

  1. All variables, including nonmodifiable (const) variables, are lvalues. So x is an lvalue whereas 0 is an rvalue.

  2. Temporary objects are made rvalues since they do not exist beyond that particular statement.

You can read more here

于 2011-12-21T06:58:40.920 に答える
1

first of all - lval and rval are properties of expressions - an expression is either an rval or an lval.

To answer your other question, temporaries created by rvals can be modified by having a rval reference - this feature is added in c++11

This feature is very useful for 1) applying move semantics 2 ) perfect forwarding.

Read more about it at http://blogs.msdn.com/b/vcblog/archive/2009/02/03/rvalue-references-c-0x-features-in-vc10-part-2.aspx

于 2011-12-21T08:35:58.957 に答える
1

RValues are things which are not maniputable regions of memory

Wrong. Rvalues absolutely are mutable. In C++03 doing this is a headache, but can be done legally- in C++11 it's extremely common.

Rvalues are expressions that yield things which are about to die. That's their defining property. Therefore, you can steal their resources without worrying about it, using C++11's rvalue references, or if you're desperate, "swaptimizing" in C++03. This makes them more correct in many situations, and much faster in many, many circumstances.

于 2011-12-21T18:35:28.180 に答える