Эти выражения равны?

Хорошие, копаясь с C# и C ++ я столкнулся с тем, что следующий тип выражений действительный:

int A, B, C, D, E;
A = B = C = D = E = 1;

Согласно этому действию, я распределяю 1 в E, E в D и так, до того, чтобы прибывать в конце концов.

Мой главный вопрос - следующий: Почему этот тип выражений стоится?

Согласно IL (Произведенный DotNetFiddle), реализовав это действие, я это получаю:

.method public hidebysig static void  Main() cil managed
{
// 
    .maxstack  2
    .locals init (int32 V_0,
                  int32 V_1,
                  int32 V_2,
                  int32 V_3,
                  int32 V_4)
    IL_0000:  nop
    IL_0001:  ldc.i4.1
    IL_0002:  dup
    IL_0003:  stloc.s    V_4
    IL_0005:  dup
    IL_0006:  stloc.3
    IL_0007:  dup
    IL_0008:  stloc.2
    IL_0009:  dup
    IL_000a:  stloc.1
    IL_000b:  stloc.0
    IL_000c:  ret
} // end of method Program::Main

И IL, произведенный следующим ассигнованием:

A = 0; B = 0; C = 0; D = 0; E = 0;

Это следующий:

.method public hidebysig static void  Main() cil managed
{
// 
    .maxstack  1
    .locals init (int32 V_0,
                  int32 V_1,
                  int32 V_2,
                  int32 V_3,
                  int32 V_4)
    IL_0000:  nop
    IL_0001:  ldc.i4.0
    IL_0002:  stloc.0
    IL_0003:  ldc.i4.0
    IL_0004:  stloc.1
    IL_0005:  ldc.i4.0
    IL_0006:  stloc.2
    IL_0007:  ldc.i4.0
    IL_0008:  stloc.3
    IL_0009:  ldc.i4.0
    IL_000a:  stloc.s    V_4
    IL_000c:  ret
} 

Я не понимаю многий из IL, но согласно предыдущему коду, методу, который распределяет переменную в другой, он занимает больше место в памяти и так, или что-то похожее (Благосклонность исправлять меня, если я болен).

Мое сомнение: Оба кода действительно реализуют то же самое?

5
задан 02.06.2016, 23:12
2 ответа

Далее объяснение IL первого случая

.method public hidebysig static void  Main() cil managed
{
// 
    .maxstack  2                  // Denota que la pila tendrá máximo 2 elementos
    .locals init (int32 V_0,      // Declara las 5 variables de tipo Int32
                  int32 V_1,
                  int32 V_2,
                  int32 V_3,
                  int32 V_4)
    IL_0000:  nop                 // Autogenerado cuando se compila como DEBUG
    IL_0001:  ldc.i4.1            // Se coloca en la pila el valor 1
    IL_0002:  dup                 // Se duplica el valor 1 en la pila como segundo elemento
    IL_0003:  stloc.s    V_4      // Se desapila el segundo 1 y se almacena en la variable V_4 (E)
    IL_0005:  dup                 // Se duplica de nuevo el valor 1
    IL_0006:  stloc.3             // Se desapila el tercer 1 y se almacena en la variable 3 (V_3/D)
    IL_0007:  dup                 // Se duplica en valor 1 en la pila
    IL_0008:  stloc.2             // Se desapila el cuarto 1 y se almacena en la variable 2 (V_2/C)
    IL_0009:  dup                 // Se duplica el valor 1 en la pila
    IL_000a:  stloc.1             // Se desapila el quinto 1 y se amancena en la variable 1 (V_1/B)
    IL_000b:  stloc.0             // Se desapila el primer 1 y se apila en la variable 0 (V_0/A)
    IL_000c:  ret
} // end of method Program::Main

В этом случае algortimo, который продолжается, состоит в том, чтобы размещать стоимость 1 в батарейке и потом удваивать эту стоимость это хранить tempralmente, чтобы мочь оставаться adignandolo, распределив это ему в соответствующую переменную, сначала в V_5 потом в V_4 и я схватил до тех пор, пока не нужно хранить временно больше переменную, в конце концов батарейка остается пустой и l стоимость 1 распределенный всем переменным

Во втором случае понимая, что выражение было: A = 1; B = 1; C = 1; D = 1; E = 1;

.method public hidebysig static void  Main() cil managed
{
// 
    .maxstack  1                  // Se define el tamaño máximo de pila en 1
    .locals init (int32 V_0,      // Se declaran las 5 variables de tipo Int32
                  int32 V_1,
                  int32 V_2,
                  int32 V_3,
                  int32 V_4)
    IL_0000:  nop                // Generado al compilar como DEBUG
    IL_0001:  ldc.i4.1           // Se apila el valor 1
    IL_0002:  stloc.0            // Se desapila el 1 y se asigna a la variable 0 (V_0/A)
    IL_0003:  ldc.i4.1           // Se apila el valor 1
    IL_0004:  stloc.1            // Se desapila el 1 y se asigna a la variable 1 (V_1/B)
    IL_0005:  ldc.i4.1           // Se apila el valor 1
    IL_0006:  stloc.2            // Se desapila el 1 y se asigna a la variable 2 (V_2/C)
    IL_0007:  ldc.i4.1           // Se apila el valor 1
    IL_0008:  stloc.3            // Se desapila el 1 y se asigna a la variable 3 (V_3/D)
    IL_0009:  ldc.i4.1           // Se apila el valor 1
    IL_000a:  stloc.s    V_4     // Se desapila el 1 y se asigna a V_4 (E)
    IL_000c:  ret
}

Из этого случая algortimo simplemento состоит, в 1 складывает в штабели стоимость и распределять это соответствующему varible. Это повторяется 5 раз.

Поскольку мы можем наблюдать в этом случае в батарейке только, имеется одновременно элемент, так как seimpre он складывается в штабели, и desapila немедленно, в предыдущем случае они имелись до двух 1 так как удваивалась та же стоимость каждый раз вместо того, чтобы складывать в штабели ту же стоимость 5 раз.

Сейчас отвечая на, потому что она действительная, первый синтаксис в C# он проистекает из следующего

= Operator у него есть стоимость возврата и это та же стоимость, которая распределяется в переменную левой стороны, а именно:

A = B = C = D = E = 1;

равняйся в

A = (B = (C = (D = (E = 1))));

и выполняя это шаг за шагом:

A = (B = (C = (D = (E = 1))));    // E == 1
...
A = (B = (C = (D = 1)));          // E == 1, D == 1
...
A = (B = (C = 1));                // E == 1, D == 1, C == 1
...
A = (B = 1);                      // E == 1, D == 1, C == 1, B == 1
...
A = 1;                            // E == 1, D == 1, C == 1, B == 1, A == 1
5
ответ дан 24.11.2019, 14:14
  • 1
    Превосходный explicaci и # 243; n c и # 243; я говорю IL –  enrique7mc 03.06.2016, 00:20
int A, B, C, D, E;
A = B = C = D = E = 1;

Мой главный вопрос - следующий, ВїPor quГ© этот тип выражений действительный?

Второе решение содержит mГєltiples выражений asignaciГіn , одна expresiГіn asignaciГіn распределяет стоимость в переменную:

A = 1;

Но эта стоимость может быть одной expresiГіn asignaciГіn из-за sГ - сам:

A = B = 1;

Сначала evalГєa expresiГіn asignaciГіn B = 1, которые заканчиваются 1 и этой стоимостью, распределяется A. Тот же процесс повторяется для всех переменных в цепи ассигнований.

мы Это находим в especificaciГіn из языка 7.13.1

The result of оцените простой assignment expression is the assigned to the left operand. The result - the same type эксперт the left operand and is always classified эксперт в value.

На уровне IL cГіdigo отличается, однако результат - тот же самый, распределив ту же стоимость во все переменные.

A = 1; B = 1; C = 1; D = 1; E = 1;
2
ответ дан 24.11.2019, 14:14
  • 1
    И поскольку он называет в это Помимо " asignaci и # 243; n" , когда я говорю: A = B = 1? –  NaCl 03.06.2016, 00:10
  • 2
    Я не думаю, что у него есть специальное имя, таким же образом как нет имени для A + B + C + D только ему называем сумма, я я передавать и # 237; в в решение такие A = B = 1 как asignaci и # 243; n м и # 250; ltiple или что-то сходное. –  enrique7mc 03.06.2016, 00:14
  • 3
    В adici и # 243; n в это и #250; ltimo, если верно, что результат - то же самое, но seg и # 250; n я вижу, один более работоспособный, чем другой относительно результата, нет? –  NaCl 03.06.2016, 00:16

Теги

Похожие вопросы