Werden zum Zeitpunkt der Kompilierung redundante Ausdrücke aus den Ausdrücken entfernt

Question

Sind redundante Ausdrücke in Ausdrücken zur Kompilierzeit entfernt?

Sagen, ich habe und der folgenden Zeilen

a = b/1; 
a = b * 1; 
a = b + 0; 
a = b - 0; 
a = b << 0; 
a = b >> 0; 

Wird der Compiler diese einfach nur a = b;

Answer 1

Tat optimieren es tut. Sie können den Disassembler in Visual Studio unter Debug ->Windows ->Disassembly öffnen, um selbst zu sehen. Ich schrieb dies:

 int a, b; 
     a = Convert.ToInt32(Console.ReadLine()); 

     b = a/1; 
     b = a * 1; 
     b = a + 0; 
     b = a - 0; 
     b = a << 0; 
     b = a >> 0; 

     Console.WriteLine("{0}", b); 

und aktiviert Optimierung für Debug Build. In der Demontage habe ich dies:

000007FE974040F4 E8 F7 62 D1 5E  call  000007FEF611A3F0 
000007FE974040F9 89 45 E4    mov   dword ptr [rbp-1Ch],eax 
000007FE974040FC 8B 4D E4    mov   ecx,dword ptr [rbp-1Ch] 
000007FE974040FF 89 4D EC    mov   dword ptr [rbp-14h],ecx 
      b = a/1; 
000007FE974242C2 8B 4D EC    mov   ecx,dword ptr [rbp-14h] 
000007FE974242C5 89 4D E8    mov   dword ptr [rbp-18h],ecx 
      b = a * 1; 
000007FE974242C8 8B 4D EC    mov   ecx,dword ptr [rbp-14h] 
000007FE974242CB 89 4D E8    mov   dword ptr [rbp-18h],ecx 
      b = a + 0; 
000007FE974242CE 8B 4D EC    mov   ecx,dword ptr [rbp-14h] 
000007FE974242D1 89 4D E8    mov   dword ptr [rbp-18h],ecx 
      b = a - 0; 
000007FE974242D4 8B 4D EC    mov   ecx,dword ptr [rbp-14h] 
000007FE974242D7 89 4D E8    mov   dword ptr [rbp-18h],ecx 
      b = a << 0; 
000007FE974242DA 8B 4D EC    mov   ecx,dword ptr [rbp-14h] 
000007FE974242DD 89 4D E8    mov   dword ptr [rbp-18h],ecx 
      b = a >> 0; 
000007FE974242E0 8B 4D EC    mov   ecx,dword ptr [rbp-14h] 
000007FE974242E3 89 4D E8    mov   dword ptr [rbp-18h],ecx 

können Sie die Montageanleitung finden Sie genau das gleiche für jede Zeile sind, es ist nur das Kopieren von a-b sechsmal. Eigentlich bin ich überrascht, dass es nicht die ganze Sache zu einer einzigen b=a Anweisung optimiert. Wenn ich die Console.WriteLine kommentieren Sie es tut:

000007FE974041D4 E8 17 62 D1 5E  call  000007FEF611A3F0 
000007FE974041D9 89 45 E8    mov   dword ptr [rbp-18h],eax 
000007FE974041DC 8B 45 E8    mov   eax,dword ptr [rbp-18h] 
000007FE974041DF 89 45 EC    mov   dword ptr [rbp-14h],eax 

      b = a/1; 
000007FE974041E2 90     nop 
      b = a * 1; 
      b = a + 0; 
      b = a - 0; 
      b = a << 0; 
      b = a >> 0; 

     // Console.WriteLine("{0}", b); 

     } 
000007FE974041E3 90     nop 

Obwohl in dass Fall, dass ich überrascht bin es nicht optimiert b völlig aus, da es nie verwendet wird. Vielleicht kann es jemand anders erklären.