Warum bedeutet die Aussage “2i;” KEINEN Compilerfehler verursachen?

Anstatt von 2*ischrieb ich nachlässig 2i:

int foo(int i)
{
    2i;
    return 2i;
}

Ich habe erwartet, dass der Compiler den Fehler abfängt. Aber das tat es nicht. So ist 2i eine gültige Aussage in C? Wenn ja, was macht es? Verwirrt!

Ich habe mit gcc Version 5.3.0 kompiliert und hier ist die Assembly-Ausgabe:

    .file   "strange.c"
    .text
    .globl  foo
    .type   foo, @function
foo:
.LFB0:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    movl    %edi, -4(%rbp)
    nop
    popq    %rbp
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE0:
    .size   foo, .-foo
    .ident  "GCC: (GNU) 5.3.0"
    .section    .note.GNU-stack,"",@progbits

Das ist ein gcc Verlängerungund 2i ist die imaginäre Konstante . Sie können also eine komplexe Zahl wie folgt schreiben:

#include <complex.h>

_Complex x = 4 + 5i;

2i ist ein gcc Erweiterung für ein komplexes Integer-Literal, eine reine imaginäre Zahl, die das Doppelte der Quadratwurzel von ist -1. Diese Erweiterung wird unterstützt von clang auch.

Es ist etwas überraschend, dass Ihre Kompilierung mit gcc 5.4.0 erzeugt die gepostete Assembly-Ausgabe:

• Kompilieren weiter http://gcc.godbolt.org/# Ich erhalte einen Kompilierungsfehler von gcc 5.3.0: http://gcc.godbolt.org/#: error: cannot convert '__complex__ int' to 'int' in return.
• Der gepostete Assemblycode für die Funktion foo ist falsch: es kehrt nicht zurück 0. Konvertieren der komplexen ganzzahligen Konstante 2i zu int sollte seinen Realteil zurückgeben 0.

Umgekehrt mit clang 3.7 kompiliert es ohne Warnung und generiert optimalen Code, aber natürlich nicht das, was Sie erwarten:

foo(int):                       # @foo(int)
    xorl    %eax, %eax
    retq

Diese Syntax kann in beliebiger Reihenfolge mit anderen Suffixen kombiniert werden. Kompilieren Sie den folgenden Code mit clang -Weverything gibt mir entsprechende Warnungen warning: imaginary constants are a GNU extension [-Wgnu-imaginary-constant]:

#include <stdio.h>

int main() {
    /* complex integer literals */
    printf("sizeof(2i) = %zd\n", sizeof(2i));
    printf("sizeof(2ui) = %zd\n", sizeof(2ui));
    printf("sizeof(2li) = %zd\n", sizeof(2li));
    printf("sizeof(2lli) = %zd\n", sizeof(2lli));
    /* complex floating point literals */
    printf("sizeof(2.i) = %zd\n", sizeof(2.i));
    printf("sizeof(2.fi) = %zd\n", sizeof(2.fi));
    printf("sizeof(2e0fi) = %zd\n", sizeof(2e0fi));
    printf("sizeof(2e0i) = %zd\n", sizeof(2e0i));
    /* alternate order */
    printf("sizeof(2il) = %zd\n", sizeof(2il));
    printf("sizeof(2ill) = %zd\n", sizeof(2ill));
    printf("sizeof(2.if) = %zd\n", sizeof(2.if));

    return 0;
}

Es erzeugt diese Ausgabe in meiner Umgebung:

sizeof(2i) = 8
sizeof(2ui) = 8
sizeof(2li) = 16
sizeof(2lli) = 16
sizeof(2.i) = 16
sizeof(2.fi) = 8
sizeof(2e0fi) = 8
sizeof(2e0i) = 16
sizeof(2il) = 16
sizeof(2ill) = 16
sizeof(2.if) = 8

Probieren Sie den letzten mit Ihrem Syntaxhervorhebungseditor aus ;-)