puis-je accéder à une structure à l’intérieur d’une structure sans utiliser l’opérateur point?

J’ai 2 structures qui ont 90% de leurs champs les mêmes. Je souhaite regrouper ces champs dans une structure mais je ne souhaite pas utiliser l’opérateur point pour y accéder. La raison en est que j’ai déjà codé avec la première structure et que je viens de créer la seconde.

avant:

typedef struct{ int a; int b; int c; object1 name; } str1; typedef struct{ int a; int b; int c; object2 name; } str2; 

maintenant je créerais une troisième structure:

 typedef struct{ int a; int b; int c; } str3; 

et changerait les str1 et atr2 en ceci:

 typedef struct{ str3 str; object1 name; } str1; typedef struct { str3 str; object2 name; } str2; 

Enfin, j’aimerais pouvoir accéder à a, b et c en faisant:

 str1 myStruct; myStruct.a; myStruct.b; myStruct.c; 

et pas:

 myStruct.str.a; myStruct.str.b; myStruct.str.c; 

Y at-il un moyen de faire une telle chose. La raison en est que je veux conserver l’intégralité des données si des modifications de la structure devaient se produire, pour ne pas me répéter, pour ne pas devoir changer mon code existant et pour ne pas avoir des champs nesteds trop profondément.

RÉSOLU: merci pour toutes vos réponses. La dernière façon de le faire pour que je puisse utiliser l’auto-complétion était aussi la suivante:

struct str11
{
int a;
int b;
int c;
};
typedef struct str22 : public str11
{
QSsortingng name;
}hi;

Oui. Plutôt en utilisant un style C d’inheritance, en utilisant le style C ++:

 struct str3{ int a; int b; int c; }; struct str2 : public str3{ object2 name; }; 

Première remarque. Ce

 struct { int a; int b; int c; } str3; 

définit un object str3, pas un type str3.

Vous pouvez réaliser ce que vous voulez en utilisant l’inheritance, mais je suggère de changer les numéros de vos structures

 struct str1 { int a; int b; int c; }; struct str2 : public str1 { object1 name; }; 

La raison en est que je veux conserver l’intégralité des données si des modifications sont apscopes à la structure.

Pour ce faire, je préfère utiliser une encapsulation, des accesseurs et un inheritance appropriés pour rendre les modifications de la disposition invisibles à partir du code utilisateur:

 class DataHolder { int a_, b_, c_; public: int a() const { return a_; } int b() const { return b_; } int c() const { return c_; } }; class User : public DataHolder { object o_; public: object& getObject() { return o_; } }; 

Je ne suis pas sûr du C ++ (j’apprends toujours le C ++), mais en C, certains compilateurs autorisent les structs anonymes. Avec GCC 4.3, les compilations suivantes ne génèrent aucune erreur si aucun indicateur n’est spécifié, mais la compilation avec -ansi ou -std=c99 . Il comstack avec succès avec -std=c++98 cependant:

 int main (int argc, char *argv[]) { struct { struct { int a; int b; int c; }; int test; } global; global.a = 1; global.b = 2; global.c = 3; global.test = 4; return global.b; } 

N’utilisez pas d’astuces stupides pour éviter une refactorisation appropriée. Cela vous épargnera un peu de dactylographie, mais cela vous mordra plus tard. Si c’est si compliqué à éditer, alors vous utilisez les mauvais outils et / ou vous avez un mauvais schéma de nommage (les noms d’une lettre sont difficiles à trouver / à remplacer).

Vous pouvez le faire avec GCC, comme mentionné dans une autre affiche, mais vous pouvez également utiliser l’ -fms-extensions qui vous permet d’utiliser une struct définie précédemment en tant que champ non nommé.

Plus ici .