Attributs C++ pour COM et .NET
Microsoft définit un ensemble d’attributs C++ qui simplifient la programmation COM et le développement common language runtime .NET Framework. Lorsque vous incluez des attributs dans vos fichiers sources, le compilateur fonctionne avec des DLL de fournisseur pour insérer du code ou modifier le code dans les fichiers objet générés. Ces attributs facilitent la création de fichiers .idl, d’interfaces, de bibliothèques de types et d’autres éléments COM. Dans l’environnement de développement intégré (IDE), les attributs sont pris en charge par les Assistants et par le Fenêtre Propriétés.
Bien que les attributs éliminent certains des codages détaillés nécessaires pour écrire des objets COM, vous avez besoin d’un arrière-plan dans les notions de base com pour les utiliser au mieux.
Remarque
Si vous recherchez des attributs standard C++, consultez Attributs.
Objectif des attributs
Les attributs étendent C++ dans les directions non possibles sans rompre la structure classique du langage. Les attributs permettent aux fournisseurs (DLL distinctes) d’étendre dynamiquement les fonctionnalités de langage. L’objectif principal des attributs est de simplifier la création de composants COM, en plus d’augmenter le niveau de productivité du développeur de composants. Les attributs peuvent être appliqués à presque n’importe quelle construction C++, comme les classes, les membres de données ou les fonctions membres. Voici un point fort des avantages offerts par cette nouvelle technologie :
Expose une convention d’appel familière et simple.
Utilise du code inséré, qui, contrairement aux macros, est reconnu par le débogueur.
Permet une dérivation facile à partir de classes de base sans détails d’implémentation fastidieux.
Remplace la grande quantité de code IDL requise par un composant COM avec quelques attributs concis.
Par exemple, pour implémenter un récepteur d’événements simple pour une classe ATL générique, vous pouvez appliquer l’attribut event_receiver à une classe spécifique telle que CMyReceiver. L’attribut event_receiver est ensuite compilé par le compilateur Microsoft C++, qui insère le code approprié dans le fichier objet.
[event_receiver(com)]
class CMyReceiver
{
void handler1(int i) { ... }
void handler2(int i, float j) { ... }
}
Vous pouvez ensuite configurer les méthodes et gérer les événements (à l’aide de la fonction intrinsèque __hook) à partir d’une source d’événement, que vous pouvez créer à l’aide de event_source.handler2 handler1 CMyReceiver
Mécanismes de base des attributs
Il existe trois façons d’insérer des attributs dans votre projet. Tout d’abord, vous pouvez les insérer manuellement dans votre code source. Ensuite, vous pouvez les insérer à l’aide de la grille de propriétés d’un objet dans votre projet. Enfin, vous pouvez les insérer à l’aide des différents Assistants. Pour plus d’informations sur l’utilisation de la fenêtre Propriétés et des différents Assistants, consultez Projets Visual Studio - C++.
Comme précédemment, lorsque le projet est généré, le compilateur analyse chaque fichier source C++, produisant un fichier objet. Toutefois, lorsque le compilateur rencontre un attribut, il est analysé et vérifié de manière syntactique. Le compilateur appelle ensuite dynamiquement un fournisseur d’attributs pour insérer du code ou apporter d’autres modifications au moment de la compilation. L’implémentation du fournisseur diffère selon le type d’attribut. Par exemple, les attributs liés à ATL sont implémentés par Atlprov.dll.
La figure suivante illustre la relation entre le compilateur et le fournisseur d’attributs.
Remarque
L’utilisation des attributs ne modifie pas le contenu du fichier source. La seule fois que le code d’attribut généré est visible pendant les sessions de débogage. En outre, pour chaque fichier source du projet, vous pouvez générer un fichier texte qui affiche les résultats de la substitution d’attribut. Pour plus d’informations sur cette procédure, consultez /Fx (Fusionner le code injecté) et déboguer du code injecté.
Comme la plupart des constructions C++, les attributs ont un ensemble de caractéristiques qui définissent leur utilisation appropriée. Il s’agit du contexte de l’attribut et est traité dans la table de contexte d’attribut pour chaque rubrique de référence d’attribut. Par exemple, l’attribut de coclasse ne peut être appliqué qu’à une classe ou une structure existante, par opposition à l’attribut cpp_quote , qui peut être inséré n’importe où dans un fichier source C++.
Générer un programmes par attributs
Après avoir placé des attributs Visual C++ dans votre code source, vous souhaiterez peut-être que le compilateur Microsoft C++ produise une bibliothèque de types et un fichier .idl pour vous. Les options d’éditeur de liens suivantes vous aident à générer des fichiers .tlb et .idl :
Certains projets contiennent plusieurs fichiers .idl indépendants. Ils sont utilisés pour produire deux fichiers .tlb ou plus et éventuellement les lier au bloc de ressources. Ce scénario n’est actuellement pas pris en charge dans Visual C++.
En outre, l’éditeur de liens Visual C++ génère toutes les informations d’attribut liées à IDL dans un seul fichier MIDL. Il n’existe aucun moyen de générer deux bibliothèques de types à partir d’un seul projet.
Contextes d’attribut
Les attributs C++ peuvent être décrits à l’aide de quatre champs de base : la cible à laquelle ils peuvent être appliqués (S’applique à), s’ils sont reproductibles ou non (reproductibles), la présence requise d’autres attributs (attributs obligatoires) et les incompatibilités avec d’autres attributs (attributs non valides). Ces champs sont répertoriés dans une table associée dans la rubrique de référence de chaque attribut. Chacun de ces champs est décrit ci-dessous.
S'applique à
Ce champ décrit les différents éléments de langage C++ qui sont des cibles légales pour l’attribut spécifié. Par exemple, si un attribut spécifie « class » dans le champ S’applique à , cela indique que l’attribut ne peut être appliqué qu’à une classe C++ légale. Si l’attribut est appliqué à une fonction membre d’une classe, une erreur de syntaxe se produit.
Pour plus d’informations, consultez Attributs par utilisation.
Renouvelable
Ce champ indique si l’attribut peut être appliqué à plusieurs reprises à la même cible. La majorité des attributs ne sont pas reproductibles.
Attributs requis
Ce champ répertorie d’autres attributs qui doivent être présents (c’est-à-dire appliqués à la même cible) pour que l’attribut spécifié fonctionne correctement. Il est rare qu’un attribut ait des entrées pour ce champ.
Attributs non valides
Ce champ répertorie d’autres attributs incompatibles avec l’attribut spécifié. Il est rare qu’un attribut ait des entrées pour ce champ.
Déboguer du code injecté
L'utilisation d'attributs peut simplifier considérablement la programmation en C++. Pour plus d’informations, consultez Concepts. Certains attributs sont interprétés directement par le compilateur. D'autres injectent du code dans la source du programme, code qui est ensuite traité par le compilateur. Ce code injecté simplifie la programmation en réduisant la quantité de code à écrire. Parfois, cependant, un bogue peut provoquer un échec de l'application pendant l'exécution du code injecté. Dans ce cas, vous voudrez probablement examiner le code injecté. Visual Studio vous permet de visualiser le code injecté de deux façons :
Vous pouvez l’afficher dans la fenêtre Code Machine.
Avec /Fx, vous pouvez créer un fichier source fusionné contenant le code d’origine et le code injecté.
La fenêtre Code Machine affiche les instructions en langage assembleur qui correspondent au code source et au code injecté par des attributs. En outre, cette fenêtre peut afficher l’annotation du code source.
Pour activer l'annotation de la source
Cliquez avec le bouton droit sur la fenêtre Code Machine puis, dans le menu contextuel, cliquez sur Afficher le code source.
Si vous connaissez l’emplacement d’un attribut dans une fenêtre source, vous pouvez utiliser le menu contextuel pour rechercher le code injecté dans la fenêtre Code Machine.
Pour afficher le code injecté
Assurez-vous que le débogueur est en mode arrêt.
Dans une fenêtre de code source, placez le curseur devant l'attribut dont vous voulez afficher le code injecté.
Cliquez avec le bouton droit puis, dans le menu contextuel, cliquez sur Atteindre le code Machine.
Si l’emplacement de l’attribut est situé à proximité du point d’exécution en cours, vous pouvez sélectionner la fenêtre Code Machine dans le menu Déboguer.
Pour afficher le code machine au point d'exécution en cours
Assurez-vous que le débogueur est en mode arrêt.
Dans le menu Déboguer, choisissez Fenêtres, puis cliquez sur Code Machine.
Dans cette section
Programmation par attributs (FAQ)
Attributs par groupe
Attributs par utilisation
Référence alphabétique des attributs