Ich habe ein Programm in C gesehen, das Code wie den folgenden hatte:

static void *arr[1]  = {&& varOne,&& varTwo,&& varThree};

varOne: printf("One") ;
varTwo: printf("Two") ;
varThree: printf("Three") ;

Ich bin verwirrt darüber, was die && tut, weil links davon nichts ist. Wird es standardmäßig als null ausgewertet? Oder ist das ein Sonderfall?

Bearbeiten: Weitere Informationen hinzugefügt, um die Frage / den Code für meine Frage klarer zu machen. Vielen Dank für die Hilfe. Dies war ein Fall der gcc-spezifischen Erweiterung.

Es ist eine gcc-spezifische Erweiterung, eine unäre && Operator, der auf einen Label-Namen angewendet werden kann und seine Adresse als liefert void* Wert.

Im Rahmen der Erweiterung goto *ptr; wo erlaubt ist ptr ist ein Ausdruck des Typs void*.

Es ist dokumentiert hier im gcc-Handbuch.

Sie können die Adresse eines in der aktuellen Funktion (oder einer enthaltenden Funktion) definierten Labels mit dem unären Operator abrufen &&. Der Wert hat Typ void *. Dieser Wert ist eine Konstante und kann überall dort verwendet werden, wo eine Konstante dieses Typs gültig ist. Zum Beispiel:

void *ptr;
/* ... */
ptr = &&foo;

Um diese Werte zu verwenden, müssen Sie in der Lage sein, zu einem zu springen. Dies geschieht mit der berechneten goto-Anweisung, goto *exp;. Zum Beispiel,

goto *ptr;

Jeder Ausdruck des Typs void * ist erlaubt.

Wie zwol in einem Kommentar betont, verwendet gcc && eher als das Offensichtlichere & weil ein Etikett und ein Objekt mit demselben Namen gleichzeitig sichtbar sein können &foo möglicherweise mehrdeutig, wenn & bedeutet “Adresse des Etiketts”. Bezeichnungsnamen belegen ihren eigenen Namensraum (nicht im Sinne von C++) und können nur in bestimmten Kontexten erscheinen: definiert durch a beschriftete Aussageals Ziel von a goto -Anweisung oder, für gcc, als Operand von unary &&.

Dies ist eine gcc-Erweiterung, die als “Labels as Values” bekannt ist. Link zur gcc-Dokumentation.

In dieser Erweiterung && ist ein unärer Operator, der auf a angewendet werden kann Etikett. Das Ergebnis ist ein Wert vom Typ void *. Dieser Wert kann später in a dereferenziert werden goto -Anweisung, damit die Ausführung zu diesem Label springt. Außerdem ist Zeigerarithmetik für diesen Wert zulässig.

Das Label muss dieselbe Funktion haben; oder in einer einschließenden Funktion, falls der Code auch die gcc-Erweiterung von “verschachtelten Funktionen” verwendet.

Hier ist ein Beispielprogramm, in dem die Funktion zur Implementierung einer Zustandsmaschine verwendet wird:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void)
{
    void *tab[] = { &&foo, &&bar, &&qux };

    // Alternative method
    //ptrdiff_t otab[] = { &&foo - &&foo, &&bar - &&foo, &&qux - &&foo };

    int i, state = 0;

    srand(time(NULL));

    for (i = 0; i < 10; ++i)
    {
        goto *tab[state];

        //goto *(&&foo + otab[state]);

    foo:
        printf("Foo\n");
        state = 2;
        continue;
    bar:
        printf("Bar\n");
        state = 0;
        continue;
    qux:
        printf("Qux\n");
        state = rand() % 3;
        continue;
    }
}

Zusammenstellung und Ausführung:

$ gcc -o x x.c && ./x
Foo
Qux
Foo
Qux
Bar
Foo
Qux
Qux
Bar
Foo

Mir ist kein Operator bekannt, der in C so funktioniert. Je nach Kontext kann das kaufmännische Und in C viele verschiedene Dinge bedeuten.

Address-Of-Operator

Direkt vor einem lvalue, zB

int j;
int* ptr = &j;

Im obigen Code ptr speichert die Adresse von j, & nimmt in diesem Zusammenhang die Adresse eines beliebigen lvalue. Der folgende Code wäre für mich sinnvoller gewesen, wenn er so geschrieben worden wäre.

static int varOne;
static int varTwo;
static int varThree;

static void *arr[1][8432] = { { &varOne,&varTwo, &varThree } };

Logisches UND

Der logische UND-Operator ist einfacher, im Gegensatz zum obigen Operator ist er ein binärer Operator, was bedeutet, dass er einen linken und einen rechten Operanden erfordert. Die Funktionsweise besteht darin, den linken und den rechten Operanden auszuwerten und wahr zurückzugeben, wenn beide wahr sind, oder größer als 0, wenn sie nicht bool sind.

bool flag = true;
bool flag2 = false;
if (flag && flag2) {
    // Not evaluated
}
flag2 = true;
if (flag && flag2) {
   // Evaluated
}

Bitweises UND

Eine andere Verwendung des kaufmännischen Und in C ist ein bitweises UND. Er ähnelt dem logischen UND-Operator, außer dass er nur ein kaufmännisches Und verwendet und eine UND-Operation auf Bitebene durchführt.

Nehmen wir an, wir haben eine Zahl und diese entspricht der unten gezeigten binären Darstellung. Die UND-Operation funktioniert folgendermaßen:

0 0 0 0 0 0 1 0
1 0 0 1 0 1 1 0
---------------
0 0 0 0 0 0 1 0

Im C++-Land werden die Dinge komplizierter. Das kaufmännische Und kann nach einem Typ platziert werden, um einen Referenztyp zu bezeichnen (Sie können es sich als eine weniger mächtige, aber sichere Art von Zeiger vorstellen), dann wird es noch komplizierter mit 1) r-Wert-Referenz, wenn zwei kaufmännische Und-Zeichen dahinter platziert werden eine Art. 2) Universelle Referenzen, wenn zwei kaufmännische Und-Zeichen nach einem Vorlagentyp oder automatisch abgezogenen Typ platziert werden.

Ich denke, Ihr Code wird aufgrund einer Art Erweiterung wahrscheinlich nur in Ihrem Compiler kompiliert. Daran dachte ich https://en.wikipedia.org/wiki/Digraphs_and_trigraphs#C aber ich bezweifle, dass das so ist.