Attribute specifier sequence (since C++11)

Introduit des attributs définis par l'implémentation pour les types, les objets, le code, etc.

Syntaxe

où attribute-list est une séquence séparée par des virgules de zéro ou plusieurs attribute s (pouvant se terminer par des points de suspension ... indiquant une pack expansion )

où attribute-namespace est un identifiant et argument-list est une séquence de jetons où les parenthèses, crochets et accolades sont équilibrés ( balanced-token-seq ).

[[using CC: opt(1), debug]] // same as [[CC::opt(1), CC::debug]]
[[using CC: CC::opt(1)]] // error: cannot combine using and scoped attribute

Explication

Les attributs fournissent la syntaxe standard unifiée pour les extensions de langage définies par l'implémentation, telles que les extensions de langage GNU et IBM __attribute__((...)) , l'extension Microsoft __declspec() , etc.

Un attribut peut être utilisé presque partout dans le programme C++, et peut être appliqué à presque tout : aux types, aux variables, aux fonctions, aux noms, aux blocs de code, aux unités de traduction entières, bien que chaque attribut particulier ne soit valide que là où il est permis par l'implémentation : [[expect_true]] pourrait être un attribut qui ne peut être utilisé qu'avec une instruction if , et non avec une déclaration de classe. [[omp::parallel()]] pourrait être un attribut qui s'applique à un bloc de code ou à une boucle for , mais pas au type int , etc (notez que ces deux attributs sont des exemples fictifs, voir ci-dessous pour les attributs standard et non standard).

Dans les déclarations, les attributs peuvent apparaître à la fois avant la déclaration entière et directement après le nom de l'entité qui est déclarée, auquel cas ils sont combinés. Dans la plupart des autres situations, les attributs s'appliquent à l'entité directement précédente.

Le alignas spécificateur fait partie de la séquence de spécificateurs d'attributs, bien qu'il ait une syntaxe différente. Il peut apparaître là où les attributs [[...]] apparaissent et peut se mélanger avec eux (à condition qu'il soit utilisé là où alignas est autorisé).

Deux jetons consécutifs de crochet gauche ( [[ ) ne peuvent apparaître que lors de l'introduction d'un spécificateur d'attribut ou à l'intérieur d'un argument d'attribut.

void f()
{
    int y[3];
    y[[] { return 0; }()] = 1;  // erreur
    int i [[cats::meow([[]])]]; // correct
}

En plus des attributs standard listés ci-dessous, les implémentations peuvent supporter des attributs non standard arbitraires avec un comportement défini par l'implémentation. Tous les attributs inconnus d'une implémentation sont ignorés sans provoquer d'erreur. (depuis C++17)

Attributs standard

Les attributs suivants sont définis par la norme C++.

Les attributs standards ne peuvent pas être syntaxiquement ignorés : ils ne peuvent pas contenir d'erreurs de syntaxe, doivent être appliqués à la cible correcte, et les entités dans les arguments doivent être ODR-use .

Les attributs standards ne peuvent pas non plus être sémantiquement ignorés : le comportement avec toutes les instances d'un attribut standard particulier supprimées aurait été un comportement conforme pour le programme original avec l'attribut présent.

Notes

La présence de chaque attribut individuel sur une plateforme donnée peut être vérifiée avec __has_cpp_attribute la macro de préprocesseur.

Exemple

[[gnu::always_inline]] [[gnu::hot]] [[gnu::const]] [[nodiscard]]
inline int f(); // déclare f avec quatre attributs
[[gnu::always_inline, gnu::const, gnu::hot, nodiscard]]
int f(); // identique à ci-dessus, mais utilise un seul spécificateur d'attribut contenant quatre attributs
// C++17 :
[[using gnu : const, always_inline, hot]] [[nodiscard]]
int f[[gnu::always_inline]](); // un attribut peut apparaître dans plusieurs spécificateurs
int f() { return 0; }
int main() {}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi

Liens externes