где rvalue хранится в c?

Термины «lvalue» и «rvalue» используются для разделения мира выражений пополам. То есть (10 + 5-3) - это выражение, которое оказывается r-значением (потому что вы не можете применить к нему оператор & - в C ++ правила более сложны). Во время выполнения нет выражений, lvalue или rvalue. В частности, они нигде не хранятся.

Вам было интересно, где было сохранено значение 12, но значение 12 не является ни lvalue, ни rvalue (в отличие от выражения 12 , которое было бы rvalue, но 12 не отображается в вашей программе).

Константы, вероятно, упрощаются во время компиляции, поэтому ваш вопрос, поставленный буквально, может не помочь. Но что-то вроде, скажем, i - j + k , которое нужно вычислять во время выполнения из некоторых переменных, может быть «сохранено» где угодно компилятору, в зависимости от архитектуры процессора: компилятор обычно пытается чтобы сделать все возможное, чтобы использовать регистры, например

 LOAD AX, i
 SUB AX, j
 ADD AX, k

, чтобы вычислить такое выражение, «сохраняя» его в регистре накопителя AX, перед назначением его некоторой ячейке памяти с помощью STORE AX, dest или тому подобное. Я был бы очень удивлен, если бы современный оптимизирующий компилятор на даже полуприличной архитектуре ЦП (да, включая x86! -) потребовал бы сбросить регистры в память для любого достаточно простого выражения!

Это зависит от компилятора. Обычно значение (12) вычисляется компилятором. Затем он сохраняется в коде, как правило, как часть инструкции немедленной сборки load / move.

Где он хранится, на самом деле полностью зависит от компилятора. Стандарт не требует такого поведения.

Типичное место можно увидеть, фактически скомпилировав код и посмотрев на вывод ассемблера:

int main (int argc, char *argv[]) {
    int a;
    a = 10 + 5 - 3;
    return 0;
}

который производит:

        .file   "qq.c"
        .def    ___main;
            .scl    2;
            .type   32;
        .endef
        .text
.globl _main
        .def    _main;
            .scl    2;
            .type   32;
        .endef
_main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $8, %esp
        andl    $-16, %esp
        movl    $0, %eax
        addl    $15, %eax
        addl    $15, %eax
        shrl    $4, %eax
        sall    $4, %eax
        movl    %eax, -8(%ebp)
        movl    -8(%ebp), %eax
        call    __alloca
        call    ___main
        movl    $12, -4(%ebp)         ;*****
        movl    $0, %eax
        leave
        ret

Соответствующий бит помечен ; ***** , и вы можете видеть, что значение создается компилятором и просто вставляется непосредственно в инструкцию типа mov .

Обратите внимание, что это так просто, потому что выражение - постоянное значение. Как только вы вводите непостоянные значения (например, переменные), код становится немного сложнее. Это потому, что вам нужно найти эти переменные в памяти (или они могут уже быть в регистре), а затем манипулировать значениями во время выполнения , а не во время компиляции .

• Результат вычисления в правой части (справа) вычисляется компилятором на этапе, который называется «постоянное распространение».
• Затем он сохраняется как операнд инструкции сборки, перемещающей значение в a

Вот разборка из MSVC:

  int a;
  a = 10 + 5 - 3;

0041338E  mov         dword ptr [a],0Ch 

Ваш вопрос основан на неверной предпосылке.

Определяющим свойством lvalue в C является то, что у него есть место в хранилище , то есть хранится . Это то, что отличает lvalue от rvalue . Rvalue нигде не хранится. Вот что делает его rvalue. Если бы это было сохранено,