Quand l'initialisation uniforme C devient-elle « l'analyse la plus fastidieuse » ?

Comprendre l'ambiguïté de « l'analyse la plus vexante » dans les initialiseurs uniformes C

L'« analyse la plus vexante » fait référence à une ambiguïté qui peut survenir lorsque en utilisant une syntaxe d'initialisation uniforme en C 11. Cette ambiguïté se produit lorsqu'il n'est pas clair si une expression de code initialise un objet ou appelle une fonction qui renvoie un objet.

Pour illustrer cette ambiguïté, considérons le code suivant :

<code class="cpp">#include <iostream>

class Timer
{
public:
    Timer() {}
};

int main() 
{
    // Case 1: Initializing an object
    auto dv = Timer();

    // Case 2: Calling a function
    int time_keeper(Timer());

    return 0;
}</code>

Cas 1 : Initialisation d'un objet

Dans le premier cas, auto dv = Timer() initialise un objet de type Timer appelé dv. Le type de dv est déduit Timer car nous utilisons auto pour le déclarer.

Cas 2 : Appel d'une fonction

Dans le deuxième cas, int time_keeper(Timer ()) déclare une fonction appelée time_keeper qui renvoie un int et prend comme argument un pointeur vers une fonction qui renvoie un Timer et ne prend aucun argument.

La raison pour laquelle l'argument n'est pas Timer (*) () est que les fonctions se désintègrent en pointeurs lorsqu'elles sont passées en argument. Par conséquent, le type de time_keeper est en fait int(Timer(*)()).

Cette ambiguïté peut être évitée en spécifiant explicitement le type de la variable en cours d'initialisation ou en déclarant explicitement la signature de la fonction. Par exemple :

<code class="cpp">// Explicitly specify the type of the variable
auto dv: Timer = Timer();

// Explicitly declare the function's signature
int time_keeper(Timer (*)());</code>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!