Other operators

Une collection d'opérateurs qui ne s'inscrivent dans aucune des autres catégories majeures.

Appel de fonction

L'expression d'appel de fonction a la forme

où

Le comportement de l'expression d'appel de fonction dépend de si le prototype de la fonction appelée est dans la portée au point d'appel.

Appel à une fonction avec un prototype

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) {}

Notes

Les évaluations de expression qui désigne la fonction à appeler et de tous les arguments sont non-séquencées les unes par rapport aux autres (mais il y a un point de séquence avant que le corps de la fonction ne commence à s'exécuter)

(*pf[f1()]) (f2(), f3() + f4()); // f1, f2, f3, f4 peuvent être appelées dans n'importe quel ordre

Bien que l'appel de fonction ne soit défini que pour les pointeurs vers des fonctions, il fonctionne avec les désignateurs de fonction grâce à la conversion implicite fonction-vers-pointeur .

int f(void) { return 1; }
int (*pf)(void) = f;
int main(void)
{
    f();    // convertit f en pointeur, puis appelle
    (&f)(); // crée un pointeur vers fonction, puis appelle
    pf();    // appelle la fonction
    (*pf)(); // obtient le désignateur de fonction, convertit en pointeur, puis appelle
    (****f)(); // convertit en pointeur, obtient la fonction, répète 4x, puis appelle
    (****pf)(); // également OK
}

Les fonctions qui ignorent les arguments inutilisés, telles que printf , doivent être appelées avec un prototype dans la portée (le prototype de ces fonctions utilise nécessairement le paramètre ellipses de fin ) pour éviter d'invoquer un comportement indéfini.

La formulation actuelle de la norme concernant la sémantique de préparation des paramètres de fonction est défectueuse, car elle spécifie que les paramètres sont assignés à partir des arguments lors de l'appel, ce qui rejette incorrectement les types de paramètres ou membres qualifiés const, et applique inappropriément la sémantique de volatile qui est irréalisable pour les paramètres de fonction sur de nombreuses plateformes. Un rapport de défaut post-C11 DR427 a proposé de modifier cette sémantique d'assignation en initialisation, mais a été clos comme n'étant pas un défaut.

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

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

Opérateur virgule

L'expression de l'opérateur virgule a la forme

où

D'abord, l'opérande gauche, lhs , est évalué et sa valeur résultante est ignorée.

Ensuite, un point de séquence intervient, de sorte que tous les effets secondaires de lhs soient terminés.

Ensuite, l'opérande droit, rhs , est évalué et son résultat est retourné par l'opérateur virgule en tant que non-lvalue .

Notes

Le type du lhs peut être void (c'est-à-dire qu'il peut s'agir d'un appel à une fonction qui retourne void , ou il peut s'agir d'une expression cast vers void )

L'opérateur virgule peut être une lvalue en C++, mais jamais en C

L'opérateur virgule peut renvoyer une structure (les seules autres expressions qui renvoient des structures sont les littéraux composés, les appels de fonction, les assignations et l'opérateur conditionnel)

Dans les contextes suivants, l'opérateur virgule ne peut pas apparaître au niveau supérieur d'une expression car la virgule a une signification différente :

• liste d'arguments dans un appel de fonction
• expression d'initialisation ou liste d'initialisation
• sélection générique

Si l'opérateur virgule doit être utilisé dans un tel contexte, il doit être mis entre parenthèses :

// int n = 2,3; // erreur, la virgule est supposée commencer le déclarateur suivant
// int a[2] = {1,2,3}; // erreur : plus d'initialiseurs que d'éléments
int n = (2,3), a[2] = {(1,2),3}; // OK
f(a, (t=3, t+2), c); // OK, d'abord, stocke 3 dans t, puis appelle f avec trois arguments

L'opérateur virgule de premier niveau est également interdit dans les bornes des tableaux

// int a[2,3]; // erreur
int a[(2,3)]; // OK, tableau VLA de taille 3 (VLA car (2,3) n'est pas une expression constante)

L'opérateur virgule n'est pas autorisé dans les expressions constantes , qu'il soit au niveau supérieur ou non

// static int n = (1,2); // Erreur : une expression constante ne peut pas appeler l'opérateur virgule

Opérateur de cast

Voir cast operator

Opérateur conditionnel

L'expression de l'opérateur conditionnel a la forme

où

Seules les expressions suivantes sont autorisées comme expression-true et expression-false

• deux expressions de tout type arithmétique
• deux expressions du même struct ou union type
• deux expressions de type void
• deux expressions de type pointeur, pointant vers des types compatibles , en ignorant les qualificatifs cvr

• une expression est un pointeur et l'autre est la constante de pointeur nul (telle que NULL ) ou une valeur nullptr_t (depuis C23)
• une expression est un pointeur vers objet et l'autre est un pointeur vers void (éventuellement qualifié)

#define ICE(x) (sizeof(*(1 ? ((void*)((x) * 0l)) : (int*)1)))
// si x est une Expression Constante Entière alors la macro se développe en
sizeof(*(1 ? NULL : (int *) 1))  // (void *)((x)*0l)) -> NULL
// selon le point (4) cela se convertit ensuite en
sizeof(int)
// si x n'est pas une Expression Constante Entière alors la macro se développe en
// selon le point (6)
(sizeof(*(void *)(x))           // Erreur due au type incomplet

Notes

L'opérateur conditionnel n'est jamais une expression lvalue , bien qu'il puisse retourner des objets de type struct/union. Les seules autres expressions pouvant retourner des structures sont l'affectation , la virgule , l'appel de fonction , et le littéral composé .

Notez qu'en C++, il peut s'agir d'une expression lvalue.

Voir la précédence des opérateurs pour les détails sur la précédence relative de cet opérateur et de l'affectation.

L'opérateur conditionnel a une associativité de droite à gauche, ce qui permet l'enchaînement

#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 opérateur

Voir sizeof operator

_Alignof opérateur

Voir opérateur _Alignof

typeof opérateurs

Voir opérateurs typeof

Références

Voir aussi

• Priorité des opérateurs