Les différentes significations de parenthèses en C++?

Capitaine Pédant à la Rescousse!

Si vous écrivez

int(value)

C'est ce qui est connu comme une une conversion de type explicite et est régi par le §5.2.3. Le libellé exact dit que

Un type simple spécificateur (7.1.5), suivie par une mise entre parenthèses de l'expression-la liste des constructions d'une valeur du type spécifié compte tenu de l'expression de la liste. Si la liste d'expression est une expression unique, la conversion de type de l'expression est l'équivalent (en definedness, et si elles sont définies dans ce sens) correspondant à l'expression cast (5.4)

(Mon emphase). Cela signifie donc que

int(value)

et

(int)value

sont complètement identiques l'un à l'autre. C'est à vous de choisir celui de ces vous trouvez plus facile à écrire.

Quant à votre deuxième question, dans l'exemple que vous avez donné avec les modèles et le tableau, je crois que ce que vous avez voulu écrire quelque chose comme cela.

template <typename T, size_t N>
size_t (T (&)[N]) {
    return N;
}

Ici, N ainsi que T est un paramètre du modèle, qui permet de passer dans tous les tableau que vous souhaitez tout en ayant le compilateur remplir N avec le nombre d'éléments dans le tableau. Dans le cas où cela ressemble à confusion (ce qui sur terre est T (&)[N]?), c'est parce que cette fonction prend un paramètre de type T (&)[N]. Pour rendre cela un peu plus facile à lire, nous allons donner à ce paramètre un nom, comme illustré ici:

template <typename T, size_t N>
size_t (T (&array)[N]) {
    return N;
}

Je pense que cela rend un peu plus facile à lire. Mais que fait cette déclaration signifie?

T (&array)[N]

Il déclare une variable appelée array qui est une référence à un tableau de Ts exactement N éléments. En effet, vous pouvez déclarer les références à des tableaux, comme vous pouvez déclarer des pointeurs de tableaux. Ce n'est pas très commun dans la pratique, mais dans ce modèle particulier idiome est une excellente façon d'avoir le compilateur de déduire la taille du tableau pour vous comme il essaie de faire correspondre le tableau à l'argument de modèle.

La raison pour laquelle les parenthèses dans ce cas est que si vous écrivez

T& array[N]

Le compilateur aurait analyser cela comme "une variable appelée array c'est un tableau de N objets, dont chacun est un T&. Cependant, le C++ spec exclut expressément les tableaux de références, et ce serait illégal. Les parenthèses explicitement lever l'ambiguïté. Ceci est similaire à des pointeurs de fonction - vous écrire

void (*functionPointer)()

au lieu de

void *functionPointer()

De faire le compilateur de réaliser que le * signifie que functionPointer est un pointeur, plutôt qu'une fonction qui retourne un void *.

Quant à la façon dont le compilateur détermine quand traiter des parenthèses dans chaque sens, les règles sont assez complexes et il y a effectivement quelques circonstances dans lesquelles le compilateur va pas analyser votre expression de la manière prévue. L'un de ces cas est quelque chose familièrement appelé "la plus délicate à analyser" dans lequel le compilateur traite de ce qui ressemble à la construction de l'objet comme un prototype de fonction. Comme un exemple, ce code:

vector<int> v();

Ne pas créer un vector<int> appelé v initialisée à l'aide du constructeur par défaut. Au lieu de cela, il traite cela comme un prototype de fonction pour une fonction appelée v qui ne prend pas d'arguments et produit un vector<int>! Toutefois, si vous deviez écrire

vector<int> v(10);

Puis le compilateur peut déduire sans ambiguïté que c'est une déclaration d'un vector<int> passant 10 comme un argument du constructeur, car il n'y a aucun moyen qu'il pouvait être considéré comme un prototype de fonction. §6.8 et le paragraphe 8.2 de la spec s'occupe de ces cas, en disant que tout ce qui peut être considéré comme une déclaration sera, et tout ce qui peut être considéré comme une fonction de prototype sera ainsi.

Le cas des parenthèses dans le contexte de la matrice (qui est, T (&array)[N]) est traité par un autre morceau de la logique, car dans le contexte dans lequel vous êtes à la déclaration d'une variable ou de la définition d'un paramètre dont le type explicite de la parenthèse, il ne peut y avoir aucune ambiguïté au sujet de votre intention car il est clair à partir du contexte que vous attribuez un nom à un type pour déclarer une variable.

Pour résumer -

1. Des empreintes de la forme T(value) et (T)value sont identiques.
2. Les parenthèses dans T (&array)[N] pour empêcher le compilateur de liaison de la & à T au lieu de array comme prévu.
3. L'usage particulier de la parenthèse est généralement déduite de contexte, même si certains problèmes peuvent arriver entre les déclarations de variables et de prototypes de fonction.

Espérons que cette aide!

OriginalL'auteur templatetypedef