Itérer sur la structure; Afficher facilement les champs de struct et les valeurs dans une boîte de richedit

Si je comprends bien correctement, le cœur de la question initiale est de savoir comment itération sur une structure. En bref, alors que Jerry Coffin a souligné dans un commentaire, cela ne peut pas être fait. Je vais essayer d'expliquer pourquoi, puis je vais essayer d'expliquer comment faire la meilleure chose à faire.

Une structure est stockée en mémoire comme une pièce monolithique de données sans métadonnées décrivant sa structure. Par exemple, la structure suivante: p> xxx pré>

peut être représentée en mémoire en utilisant une notation hexadécimale comme suit p> xxx pré>

où le premier 3 octets contiennent les champs de caractères, le quatrième est une valeur aléatoire utilisée pour le remplissage, et les quatre octets suivants sont la représentation Little-Endian de l'entier 122. Cette mise en page varie d'un compilateur au compilateur et au système au système. En bref, la représentation binaire ne vous dit pas quelles sont les données ou où des champs individuels sont stockés. P>

Alors, comment les champs d'accès du compilateur dans des structures? Le code p> xxx pré>

est traduit dans une instruction comme p> xxx pré>

en d'autres termes, le compilateur code les décalages littéraux de la champs dans le code. Encore une fois, cela ne nous aide pas. P>

Par conséquent, nous devons annoter la structure nous-mêmes. Cela peut être fait en ajoutant des informations à l'intérieur de la structure pour la transformer en une sorte de magasin de valeur de clé ou en ajoutant une deuxième structure. Vous ne voulez pas changer la structure d'origine, une deuxième structure est donc la voie à suivre. P>

Je suppose que votre structure ne contient que des types de base: int, char, etc. Si vous êtes complexe d'autres classes dans la structure, alors je suggère d'ajouter une méthode de tostring () à leur classe de base et d'appeler cette méthode - c'est comme ça que C # et Java le font. P>

Foo tmp;

#define FIELD_OFFSET(f) ((char*)&(tmp.f) - (char*)&tmp)

enum FieldType { INT_FIELD, CHAR_FIELD, OBJECT_FIELD };

struct StructMeta {
    FieldType type;
    size_t offset;
};

StructMeta[] metadata = {
   {CHAR_FIELD, FIELD_OFFSET(a)},
   {CHAR_FIELD, FIELD_OFFSET(b)},   
   {CHAR_FIELD, FIELD_OFFSET(c)},
   {INT_FIELD, FIELD_OFFSET(i)},
   {OBJECT_FIELD, FIELD_OFFSET(o)},
}

void RenderStruct(Foo* f)
{
    for (int i = 0; i < sizeof(metadata)/sizeof(StructMeta); i++)
    {
        switch (metadata[i].type)
        {
             case CHAR_FIELD:
                 char c = *((char*)f + metadata[i].offset);
                 // render c
                 break;
             case INT_FIELD:
                 int i = *(int*)((char*)f + metadata[i].offset);
                 // render i
                 break;
             case OBJECT_FIELD:
                 Object* o = (object*)((char*)f + metadata[i].offset);
                 const char* s = o->ToString();
                 // render s
                 break;    
        }
    }
}

Étant donné que vous avez un nombre assez grand de champs dans la structure, utilisez un analyseur ou écrivez le vôtre pour générer un code source pour imprimer les membres, leurs noms et leurs valeurs.

comme un exercice intéressant, le temps vous-même comme vous écrivez l'utilitaire. Vous pouvez savoir que l'utilisation d'un éditeur disposant de la recherche d'expression régulière et de remplacer la capacité peut être plus rapide.

Sinon, jetez votre conception actuelle et adoptez un nouveau. J'ai utilisé une conception d'enregistrements et de champs. Chaque enregistrement (structure) a un vecteur d'un ou plusieurs pointeurs à un field_interface . Le field_interface a des méthodes telles que get_field_name () et get_sql_data_type_text () . N'oubliez pas non plus que Java Favoris Tostring () qui renvoie la valeur de champ en tant que chaîne. Cette technique vous permet d'iTerrer sur un conteneur de champs et d'imprimer leurs valeurs (en utilisant Tostring ) et leur nom (utilisant get_field_name () ).

Ajouter le motif visiteur pour la lecture et l'écriture (j'appelle les lecteurs et les écrivains) et vous avez des champs et des enregistrements hautement adaptables sans changer leur contenu interne. En outre, cela conduit merveilleusement dans la programmation générique où vous pouvez utiliser des champs et des enregistrements sans connaître leurs types; ou avoir cela pris en charge au niveau des feuilles.

BTW, au moment où vous avez attendu la réponse parfaite, vous auriez pu écrire une fonction pour "itérer" ou visiter les membres de la structure.