Comment utiliser les attributs de C # - C # en C ++

pour les attributs de classe, oui. Définissez simplement une classe de base appelée attributs pour stocker les informations d'attribut et hériter de toute classe qui nécessite des attributs. Vous pouvez interroger pour cela en utilisant RTTI CAST.

mais pour les attributs de méthode ou de paramètre, c'est essentiellement pas une option.

C ++ 0x prendra en charge les attributs limités. Mais je doute que cela vous aide avec votre projet actuel, ou même vos prochains projets (ce ne sera pas ici pendant un moment).

Je vais répondre en supposant que vous parlez de propriétés, une fonctionnalité que j'ai Souvent convoité.

Vous pouvez un peu soutenir des propriétés. Une implation générale de cela serait un peu plus complexe. Mais pour un offs, il peut être facile xxx

i ignoré conscroiness pour le souci de brièveté.

Les attributs décrivent les métadonnées. Vous pouvez le faire «manuellement» en héritant d'une classe de base qui définit un référentiel de «descriptions» pour des pièces de classe comme des méthodes. Vous auriez besoin des noms des pièces au moment de la compilation.

class whatever
{
public:
    static map<string, string> attribute_repository;
}

Dans l'exemple MVC, vous vous référez, les attributs de méthode sont utilisés via une réflexion. Étant donné que C ++ n'a aucune réflexion, vous pouvez envisager d'utiliser la génération de code à la place: une sorte de langage de définition d'interface et un générateur produisant C ++ Code. Dans ce scénario, vous êtes libre d'ajouter un concept d'attribut à votre langue d'interface et de rendre le générateur traduire les attributs de manière appropriée.

Un excellent exemple est Google Tampons de protocole : il y a un . Format de proto pour la définition de messages, notamment les "options" (un concept très proche des attributs .net). Il existe également des compilateurs à différentes langages de programmation, y compris C ++. Ce dernier génère des fichiers .h / .cpp pour les messages décrits par le format .Proto. Les classes générées en particulier fournissent une fonctionnalité de réflexion, qui permet de vérifier par programmation si certaines options ont été définies pour les services / méthodes / messages / etc.

Évidemment, l'approche de génération de code n'est pas facile à mettre en œuvre, mais elle peut produire des solutions très efficaces.

à "attacher un comportement supplémentaire à une classe d'exécution" dans la plupart des OO Langue, je vous recommande le Stratégie Modèle de conception - avoir la classe (et / ou ses instances) détenir (via un pointeur en C ++, une référence [réactive] dans d'autres langues) une instance d'une interface / une classe abstraite appropriée appelée "interface de stratégie" ( Avec une méthode [virtuelle en C ++, non finale, dans des langues finales , etc - iow, une méthode ! -)] par point d'extensibilité) , et fournissez généralement des méthodes de getter et de réglage (ou des propriétés ou tout ce qui est approprié à la langue spécifique) pour accéder et modifier cette instance.

Enfin, la classe ou l'instance doit déléguer toutes les fonctionnalités appropriées via les méthodes de l'instance d'interface de stratégie qu'il contient.

Je recommande souvent cette approche "de la cérémonie de haute cérémonie" (pour cet objectif spécifique), même dans des langages dynamiques telles que Python ou Ruby, ce qui permettrait également des approches plus informelles via le typage du canard et la capacité d'un objet de classe à atteindre directement Les internes d'une autre - de telles capacités dynamiques parlent généralement assez utiles, mais dans ce but spécifique (comme je pense "changer un comportement de classe au moment de l'exécution") une approche plus architecturée et contrôlée, dans mon expérience, conduit à mieux Code maintenu et plus clair (ce bit est controversé: de nombreux développeurs dans des communautés de langues dynamiques telles que des approches de «remise en forme de singe», même dans de telles situations, mais une douzaine d'années de pratique de développement réussie dans des langues dynamiques, principalement python, ont fait de moi autrement enclins).

Dans le cas approprié, vous pouvez modifier l'approche de stratégie fondamentale DP de différentes manières; Par exemple, lorsque la fonctionnalité modifiable tombe proprement dans quelques groupes cohérents, il est préférable de "fragmenter" l'objet de stratégie en plusieurs simples et cohérents (dessinstrateurs, persistancestratestratestratestratestratestratestrates, etc.).

Cette approche ne prend pas la place de l'analyse appropriée et de la conception appropriée, car elle n'autorisera pas l'extension d'une fonctionnalité de classe le long d'un axe qui n'a pas été initialement pris en compte; L'approche est plutôt conçue comme une bonne façon de architecte une conception bien pensée, fournissant des "crochets" pour une extensibilité de manière bien contrôlée. Si de nouvelles considérations entrent en jeu, il peut encore être nécessaire de bien faire une introduction à la conception des classes pour couvrir de telles nouvelles idées. Mais ensuite, le développement itératif (y compris les modifications et les extensions à la conception originale) est inévitable dans tout projet riche et complexe réel - la stratégie DP n'est qu'une flèche dans votre carquois pour aider à rendre le processus plus ordonné et plus efficace.

demandez-vous une programmation orientée forme? AspectC ++ est actuellement juste un prototype de recherche :( http://www.aspectc.org/

Une idée sur la façon de "simuler" un attribut de classe à l'aide de modèles de spécialisation: xxx

La mise en oeuvre par défaut des attributs sera prise en charge par le compilateur pour une classe sans attributs: xxx

Si nous voulons appliquer les attributs à une classe, nous utilisons la spécialisation de modèle: xxx

Nous devons appliquer (modèle- Spécialiser) Les attributs de chaque classe que nous voulons qu'ils soient appliqués à: xxx

exemple: xxx

de cette manière Les attributs sont "appliqués" à la classe et non à l'instance comme avec plusieurs héritage; La différence fondamentale, de toute façon, est que, dans ce cas, les attributs sont évalués à l'heure de la compilation et non au moment de l'exécution.

EDIT : modifié l'exemple pour montrer comment appliquer plusieurs attributs à une classe et comment appliquer le même attribut à plusieurs classes.

Répondre à cette question a été amusant pour moi; En tout cas, je pense que le meilleur conseil sur le sujet est que vous ne devriez pas essayer de programmer en C ++ comme si c'était C #. En tout cas, codage heureux!

Construisez-vous un pré-processeur qui transforme un attribut comme la syntaxe en propriétés réelles et les méthodes.

J'avais lu un article sur codeProject à propos de ce numéro: C ++ Mise en œuvre de la propriété C # et de l'indexeur avec des modificateurs d'accessores . Je crois que c'est ce que tu veux.