Other operators

Eine Sammlung von Operatoren, die nicht in eine der anderen Hauptkategorien passen.

Funktionsaufruf

Der Funktionsaufrufausdruck hat die Form

wo

Das Verhalten des Funktionsaufrufausdrucks hängt davon ab, ob der Prototyp der aufgerufenen Funktion im Gültigkeitsbereich am Aufrufort vorhanden ist.

Aufruf einer Funktion mit einem Prototyp

void f(char* p, int x) {}
int main(void)
{
    f("abc", 3.14); // array to pointer and float to int conversions
}

void f(); // no prototype
int main(void)
{
    f(1, 1.0f); // UB unless f is defined to take an int and a double
}
void f(int a, double c) {}

Hinweise

Die Auswertungen von expression , die die aufzurufende Funktion bezeichnen, und aller Argumente sind unsequenced zueinander (jedoch gibt es einen Sequence Point bevor der Rumpf der Funktion mit der Ausführung beginnt)

(*pf[f1()]) (f2(), f3() + f4()); // f1, f2, f3, f4 können in beliebiger Reihenfolge aufgerufen werden

Obwohl der Funktionsaufruf nur für Zeiger auf Funktionen definiert ist, funktioniert er mit Funktionsbezeichnern aufgrund der impliziten Funktion-zu-Zeiger-Konvertierung .

int f(void) { return 1; }
int (*pf)(void) = f;
int main(void)
{
    f();    // f in Zeiger konvertieren, dann aufrufen
    (&f)(); // Zeiger auf Funktion erstellen, dann aufrufen
    pf();    // Funktion aufrufen
    (*pf)(); // Funktionsbezeichner erhalten, in Zeiger konvertieren, dann aufrufen
    (****f)(); // In Zeiger konvertieren, Funktion erhalten, 4x wiederholen, dann aufrufen
    (****pf)(); // ebenfalls OK
}

Funktionen, die ungenutzte Argumente ignorieren, wie zum Beispiel printf , müssen mit einem Prototyp im Gültigkeitsbereich aufgerufen werden (der Prototyp solcher Funktionen verwendet notwendigerweise den nachgestellten Ellipsen -Parameter), um undefiniertes Verhalten zu vermeiden.

Die aktuelle Standardformulierung der Semantik zur Vorbereitung von Funktionsparametern ist fehlerhaft, da sie festlegt, dass Parameter beim Aufruf von Argumenten zugewiesen werden, was fälschlicherweise const-qualifizierte Parameter- oder Membertypen ablehnt und unangemessen die Semantik von volatile anwendet, die für Funktionsparameter auf vielen Plattformen nicht implementierbar ist. Ein Post-C11-Fehlerbericht DR427 schlug eine Änderung dieser Semantik von Zuweisung zu Initialisierung vor, wurde jedoch als kein Fehler geschlossen.

extern int identifier(); // returns int and has no prototype

main()
{
    int n = atoi("123"); // implicitly declares atoi as int atoi()
}

Komma-Operator

Der Komma-Operator-Ausdruck hat die Form

wo

Zuerst wird der linke Operand, lhs , ausgewertet und sein Ergebniswert verworfen.

Dann findet ein Sequenzpunkt statt, sodass alle Nebeneffekte von lhs abgeschlossen sind.

Dann wird der rechte Operand, rhs , ausgewertet und sein Ergebnis wird durch den Komma-Operator als ein Non-Lvalue zurückgegeben.

Hinweise

Der Typ des lhs kann void sein (das heißt, es kann sich um einen Aufruf einer Funktion handeln, die void zurückgibt, oder es kann ein Ausdruck sein, der durch eine Cast -Operation zu void umgewandelt wird)

Der Komma-Operator kann in C++ ein Lvalue sein, aber niemals in C

Der Komma-Operator kann eine Struktur zurückgeben (die einzigen anderen Ausdrücke, die Strukturen zurückgeben, sind zusammengesetzte Literale, Funktionsaufrufe, Zuweisungen und der bedingte Operator)

In den folgenden Kontexten kann der Komma-Operator nicht auf der obersten Ebene eines Ausdrucks erscheinen, da das Komma eine andere Bedeutung hat:

• Argumentenliste in einem Funktionsaufruf
• Initialisierungsausdruck oder Initialisierungsliste
• Generic Selection

Wenn der Komma-Operator in einem solchen Kontext verwendet werden muss, muss er in Klammern gesetzt werden:

// int n = 2,3; // Fehler: Komma wird als Beginn des nächsten Deklarators angenommen
// int a[2] = {1,2,3}; // Fehler: Mehr Initialisierer als Elemente
int n = (2,3), a[2] = {(1,2),3}; // OK
f(a, (t=3, t+2), c); // OK, speichert zuerst 3 in t, ruft dann f mit drei Argumenten auf

Der Top-Level-Komma-Operator ist in Array-Grenzen ebenfalls nicht erlaubt

// int a[2,3]; // Fehler
int a[(2,3)]; // OK, VLA-Array der Größe 3 (VLA, da (2,3) kein konstanter Ausdruck ist)

Der Komma-Operator ist nicht erlaubt in konstanten Ausdrücken , unabhängig davon, ob er auf oberster Ebene steht oder nicht

// static int n = (1,2); // Fehler: Konstante Ausdrücke können den Komma-Operator nicht aufrufen

Cast-Operator

Siehe cast operator

Bedingter Operator

Der bedingte Operatorausdruck hat die Form

wo

Nur die folgenden Ausdrücke sind als expression-true und expression-false erlaubt

• zwei Ausdrücke beliebigen arithmetischen Typs
• zwei Ausdrücke desselben struct - oder union -Typs
• zwei Ausdrücke vom void-Typ
• zwei Ausdrücke vom Zeigertyp, die auf Typen zeigen, die kompatibel sind, unter Ignorierung von CVR-Qualifizierern

• ein Ausdruck ist ein Zeiger und der andere ist die Nullzeiger-Konstante (wie NULL ) oder ein nullptr_t -Wert (seit C23)
• ein Ausdruck ist ein Zeiger auf Objekt und der andere ist ein Zeiger auf void (möglicherweise qualifiziert)

#define ICE(x) (sizeof(*(1 ? ((void*)((x) * 0l)) : (int*)1)))
// falls x ein Integer-Konstantenausdruck ist, dann expandiert das Makro zu
sizeof(*(1 ? NULL : (int *) 1))  // (void *)((x)*0l)) -> NULL
// gemäß Punkt (4) konvertiert dies weiter in
sizeof(int)
// falls x kein Integer-Konstantenausdruck ist, dann expandiert das Makro zu
// gemäß Punkt (6)
(sizeof(*(void *)(x))           // Fehler aufgrund unvollständigen Typs

Hinweise

Der bedingte Operator ist niemals ein Lvalue-Ausdruck , obwohl er Objekte vom Typ Struct/Union zurückgeben kann. Die einzigen anderen Ausdrücke, die Structs zurückgeben können, sind Zuweisung , Komma , Funktionsaufruf und zusammengesetztes Literal .

Beachten Sie, dass es sich in C++ um einen Lvalue-Ausdruck handeln kann.

Siehe Operator-Präzedenz für Details zur relativen Priorität dieses Operators und Zuweisung.

Der bedingte Operator hat Rechts-nach-links-Assoziativität, was Verkettung ermöglicht

#include <assert.h>
enum vehicle { bus, airplane, train, car, horse, feet };
enum vehicle choose(char arg)
{
    return arg == 'B' ? bus      :
           arg == 'A' ? airplane :
           arg == 'T' ? train    :
           arg == 'C' ? car      :
           arg == 'H' ? horse    :
                        feet     ;
}
int main(void)
{
    assert(choose('H') == horse && choose('F') == feet);
}

sizeof Operator

Siehe sizeof-Operator

_Alignof Operator

Siehe _Alignof operator

typeof Operatoren

Siehe typeof-Operatoren

Referenzen

Siehe auch

• Operatorpräzedenz