accéder à une structure [C++]

[narakphysics]

Bonjour
J'ai une interface graphique permettant de sélectionner un élément qui sera récupérer comme un QString.
Le nom de cet élément appartient à une structure.
exemple :

 
       
structA{          
 union{
        vuint32_t R;
        struct{
                 vuint32_t x:1;
                 vuint32_t y:1;
                 vuint32_t z:1;
                 vuint32_t t:1;
                 vuint32_t :28;
               }B;
     }A1;
};

Pour accéder à x, on tape: A.A1.B.x;
Donc à partir de l'interface on demande à l'utilisateur de taper le bit, si par exemple, il a tapé : A.A1.B.x
Dans mon code je récupère une chaîne de caractère "A.A1.B.x". Est ce qu'il y a un moyen pour accéder à la structure à partir de ce nom???
merci d'avance
-----

[PA5CAL]

Bonjour

Le langage C++ est un langage entièrement compilé. Contrairement aux langages de script, interprétés ou semi-compilés, lorsque le programme est créé (compilation + édition de liens), les noms données aux différents éléments (fonctions, variables, etc.) sont remplacés par les adresses correspondantes en mémoire. Les noms sont donc au final ignorés du programme lui-même.

Si tu souhaites pouvoir désigner une variable par un nom donné par l'utilisateur, alors il faudra faire un programme qui re-traduise chacun des noms envisagés en l'adresse de la variable correspondante, en tenant compte des éventuelles différences de type de ces variables.

[narakphysics]

Merci M PASCAL de votre réponse
j'ai bien compris le problème
pour les adresses, j'ai déjà déclaré une constante qui vaut la valeur de la structure A.

#define A_A1 (*(volatile struct A *) 0xFEE26)

Dans ce cas que doit je faire ?

[PA5CAL]

Il faut en plus créer un tableau contenant les noms de variables sous la forme de chaînes de caractère, chacun associé aux éléments permettant de retrouver l'adresse, et éventuellement le type.

Voici un exemple (très) simplifié :

typedef struct {
  char* nom;
  void* adresse;
  int bit;
} REF;

REF tableRef[] = {
  {"A.A1.B.x", &(A.A1), 0},
  {"A.A1.B.y", &(A.A1), 1},
  {"A.A1.B.z", &(A.A1), 2},
  {"A.A1.B.x", &(A.A1), 3},
// ...
  {NULL, NULL, 0}
};

REF* rechercheRef(char* nomRecherche)
{
  for (REF* pref=tableRef; pref->nom!=NULL; pref++) {
    if (!strcmp(pref->nom, nomRecherche))
      return pref;
  }
  return NULL;
}

et son utilisation possible :

  char input[16];
  scanf("%8s", input);
  REF* p = rechercheRef(input);
  if (p==NULL)
    printf("%s: inconnu\n", input);
  else
    printf("%s: %d\n", input, (*(vuint32_t *)(p->adresse))>>(p->bit))&1;

[A voir en vidéo sur Futura]

[narakphysics]

Re.
le compilateur m'affiche un message d'erreur au niveau :

void*adresse;

Voici l'erreur :

invalid conversion from 'volatile void*' to 'void*' [-fpermissive]

donc j'ai changé cette ligne par :

volatile void*adresse;

Maintenant ça marche mais au niveau de fonctionnement non:
si je tape une chaîne autre que : "A.A1.B.x","A.A1.B.y","A.A1.B.z" et "A.A1.B.t" , il m'affiche inconnu comme prévu. en revanche si je tape "A.A1.B.x" il m'affiche : le programme.exe a cessé de fonctionner ==>fermer le programme!!!

[PA5CAL]

Le programme marche chez moi sans modification (je relis les bits préalablement positionnés), mais on n'utilise certainement pas les mêmes options de compilation, ni la même plateforme.

Quoi qu'il en soit, le bout de code que j'ai donné n'avait pas vraiment pour but d'être recopié tel quel, mais devait donner une idée du programme à faire et t'inspirer dans la façon de traiter le problème.

Au lieu de perdre du temps à chercher ce qui provoque le plantage (probablement un accès interdit dû à un mauvais calcul d'adresse ou à un débordement de pile), tu devrais plutôt t'attacher à réaliser un code réellement adapté à ta situation.

[narakphysics]

Oui je l'ai adapté pour voir est ce que ça marche chez moi ou non :
voici le code :

#ifndefSTRINGTOVAL_H
#defineSTRINGTOVAL_H
#include<target_Def.h>
#include<string.h>
typedefstruct{
char*nom;
volatilevoid*adresse;
intbit;
}REF;


REFtableRef[]={
{"SIU.PCR[1].B.OBE",&(SIU.PCR[1].R),0},
{"SIU.PCR[1].B.IBE",&(SIU.PCR[1].R),1},
{"SIU.PCR[1].B.ODE",&(SIU.PCR[1].R),2},
{"SIU.PCR[1].B.WPE",&(SIU.PCR[1].R),3},
{NULL,NULL,0}
};


REF*rechercheRef(char*nomRecherche)
{
for(REF*pref=tableRef;pref->nom!=NULL;pref++){
if(!strcmp(pref->nom,nomRecherche))
returnpref;
}
returnNULL;
}#endif// STRINGTOVAL_H

#include<iostream>
#include<stdio.h>
#include<stringtoval.h>
usingnamespacestd;


intmain()
{
charinput[16];
printf("La chaine : \n");
scanf("%8s",input);
REF*p=rechercheRef(input);
if(p==NULL)
printf("%s: inconnu\n",input);
else
printf("%s: %x\n",input,(*(vuint32_t*)(p->adresse))>>(p->bit))&1;
return0;
}

[PA5CAL]

Mea culpa. J'ai fait un copié collé de mon premier jet, et non pas du fichier corrigé des deux erreurs suivantes :

REF tableRef[] = {
  {"A.A1.B.x", &(A.A1), 0},
  {"A.A1.B.y", &(A.A1), 1},
  {"A.A1.B.z", &(A.A1), 2},
  {"A.A1.B.t", &(A.A1), 3},
// ...
  {NULL, NULL, 0}
};

    printf("%s: %d\n", input, (*(vuint32_t *)(p->adresse))>>(p->bit)&1);

Mais ça ne devrait pas changer grand chose pour ton plantage.

[EDIT: nos messages se sont croisés]

[narakphysics]

Oui, toujours il se plante!!

[PA5CAL]

Oui je l'ai adapté pour voir est ce que ça marche chez moi ou non :
voici le code :
...

Pour savoir si ça peut marcher, il faut absolument savoir comment la structure SIU a été déclarée.

PS: le code colorisé, c'est bien pour la compréhension. En revanche ça fait sauter quelques espaces qui sont nécessaires à la compilation.

[narakphysics]

Voici la déclaration de SIU:

    struct SIU_tag {
        union {               
            vuint16_t R;
            struct {
                vuint16_t OBE:1;
                vuint16_t  IBE:1;
                vuint16_t ODE:1;
                vuint16_t HYS:1;
                vuint16_t WPE:1;
                vuint16_t WPS:1;
                vuint16_t:10;
            } B;
        } PCR[512];
}

Avec :

 #define SIU(*(volatile struct SIU_tag*) 0xC3F90000) 

[narakphysics]

J'ai localisé le problème :
En fait ,j'ai essayé cette ligne :

printf("%s: %x\n",input,(p->adresse));

et ça marche, elle donne l'adresse du registre voulu.
Par contre cette écriture ça marche pas:

printf("%s: %x\n",input,(*(vuint32_t*)(p->adresse))>>(p->bit)&1);

[PA5CAL]

Je ne sais pas sur quelle plateforme tu tentes de faire tourner le programme (Windows?), mais le fait d'imposer toi-même l'adresse de la structure explique peut-être le plantage. En effet, rien ne permet de dire a priori si cette adresse correspond à de la mémoire physique, libre, et dont l'accès a été autorisé par le système.

[PA5CAL]

Par contre cette écriture ça marche pas:

printf("%s: %x\n",input,(*(vuint32_t*)(p->adresse))>>(p->bit)&1);

Ça semble confirmer ce que je viens d'indiquer. La tentative d'accès au contenu de la structure doit provoquer le plantage.

[narakphysics]

Je ne sais pas sur quelle plateforme tu tentes de faire tourner le programme (Windows?), mais le fait d'imposer toi-même l'adresse de la structure explique peut-être le plantage. En effet, rien ne permet de dire a priori si cette adresse correspond à de la mémoire physique, libre, et dont l'accès a été autorisé par le système.

Oui, j'ai déjà vérifié ce problème. je peux accéder à cette adresse.
La preuve est ici.

[PA5CAL]

Oui, j'ai déjà vérifié ce problème. je peux accéder à cette adresse.
La preuve est ici.

Je te parle d'accéder à la mémoire située à cette adresse, pas de connaître la valeur de cette adresse.

[narakphysics]

Je te parle d'accéder à la mémoire située à cette adresse, pas de connaître la valeur de cette adresse.

Ah !! désolé
Comment je peux savoir si cette zone est réservé pour le système ou non ??

[narakphysics]

Merci M PASCAL pour le temps que vous m'avez donné
A+

[PA5CAL]

Comment je peux savoir si cette zone est réservé pour le système ou non ??

Si le système gère l'accès à la mémoire (pagination, protection, etc.), alors celui-ci présente des fonctions que le programme peut appeler afin d'obtenir une autorisation ou une réservation.

Sur les moyens et gros systèmes (de type Windows, Linux, Mac OS, etc.) accéder à des adresses fixes est extrêmement rare. À moins de vouloir adresser directement la mémoire d'un périphérique par exemple, c'est généralement le système qui décide de la mémoire allouée à un programme lorsque celui-ci en fait la demande.

Le langage C++ inclut certains mécanismes afin d'obtenir cette mémoire plus ou moins automatiquement.

L'instanciation d'une variable ou d'un objet réserve implicitement la mémoire nécessaire à cette variable ou à cet objet. Le simple fait d'écrire :

int table[25];

réserve 25 entier de type int en mémoire, et le programme peut y accéder en utilisant le mot table (l'adresse de départ de cette zone est égale à &table[0] et n'est connue qu'au cours de l'exécution du programme).

Il est également possible de créer dynamiquement des variables ou des objets en réclamant explicitement de la mémoire au système, lequel retourne au programme l'adresse de départ de la zone de mémoire qu'il a allouée. Ce peut être réalisé à l'aide de l'opérateur new :

int pval = new int;
int* ptable = new int[25];

Mais alors il ne faut pas oublier de rendre (libérer) cette mémoire avant de quitter le programme, à l'aide de l'opérateur delete :

delete pval;
delete[] ptable;

On peut également encore utiliser les fonctions malloc() et free(), qui proviennent du langage C dont le C++ a hérité, mais toutefois sans présenter les avantages de new et delete pour la programmation objet.


En conséquence, si rien n'imposer de devoir fixer ton tableau de structures SIU à une adresse bien particulière, tu aurais tout intérêt à utiliser les facilités offertes par le langage, comme par exemple :

// déclaration du type
typedef struct SIU_tag {
  union {
    vuint16_t R;
    struct {
      vuint16_t OBE:1;
      vuint16_t IBE:1;
      vuint16_t ODE:1;
      vuint16_t HYS:1;
      vuint16_t WPE:1;
      vuint16_t WPS:1;
      vuint16_t:10;
    } B;
  } PCR[512];
} SIU_type;

puis :

  SIU_type SIU; // instanciation de la structure dans le corps du programme

...

  SIU.B.OBE = 0; // utilisation

ou bien encore :

  SIU_type *pSIU = new SIU_type; // réservation de la structure en mémoire

...

  pSIU->B.OBE = 0; // utilisation

...

  delete pSIU; // libération de la mémoire une fois le travail terminé

(mais ici pSIU est un pointeur)

[PA5CAL]

Oups... j'ai oublié PCR. Il faut lire :

  SIU_type SIU; // instanciation de la structure dans le corps du programme

...

  SIU.PCR[i].B.OBE = 0; // utilisation

ou bien encore :

  SIU_type *pSIU = new SIU_type; // réservation de la structure en mémoire

...

  pSIU->PCR[i].B.OBE = 0; // utilisation

...

  delete pSIU; // libération de la mémoire une fois le travail terminé

[PA5CAL]

Je dois quand même faire remarquer que l'utilisation des structures est plutôt une réminiscence du langage C. En pur langage C++, elles ont été remplacées par les objets, décrits par des classes (class), et qui apportent des avantages supplémentaires au niveau de l'écriture des programmes et de la manipulation des données.

Mais cela figure dans tous les cours et tutoriels sur le langage C++.

[narakphysics]

Merci encore une fois
votre explication est très claire.
Juste une remarque,j'ai pas bien compris la phrase suivante :

(l'adresse de départ de cette zone est égale à &table[0] et n'est connue qu'au cours de l'exécution du programme)

normalement au moment du linkage, on donne les adresses à toutes les variables globales. Sauf si vous considérez table[i] comme étant une variable local.
Donc puisque je développe en utilisant C++ donc c'est mieux d'utiliser le mot clé new. n'est ce pas?

Si vous permettez, pourriez vous me donner un cours en C embarqué qui explique surtout les pointeurs (Vraiment ils sont difficiele !! ). par exemple l'explication du type: void* ....
Merci d'avance

[PA5CAL]

(l'adresse de départ de cette zone est égale à &table[0] et n'est connue qu'au cours de l'exécution du programme)

normalement au moment du linkage, on donne les adresses à toutes les variables globales. Sauf si vous considérez table[i] comme étant une variable local.

En fait, a priori l'édition de lien n'attribut aux variables globales qu'une adresse relative, qui peut être modifiée au moment du chargement du programme en mémoire. Seules certaines architectures basées sur la virtualisation de la mémoire autorisent à conserver ces adresses calculées au moment de l'édition de lien. Quoi qu'il en soit, ces adresses sont a priori inconnues au moment où l'on tape le code du programme.

De plus, l'emploi de variables globales s'avère en règle générale relativement minoritaire. Les variables sont le plus souvent locales (déclarées dans le corps des fonctions) ou dynamiques (créées à l'aide d'un appel à new par exemple).

Donc puisque je développe en utilisant C++ donc c'est mieux d'utiliser le mot clé new. n'est ce pas?

Si le but est de créer une variable dynamique, certainement. Mais...

Quand on a recours à des variables dynamiques, c'est parce qu'on a de bonnes raisons de le faire :
- soit parce que leurs caractéristiques (taille, type) ne peuvent être déterminées qu'au moment de l'exécution,
- soit parce que leur taille est tellement importante qu'on souhaite pouvoir les éliminer au cours de l'exécution du programme afin de libérer de la mémoire pour d'autres traitements.
Les variables dynamiques aboutissent à devoir manipuler des pointeurs, qui sont souvent source de problème parce qu'ils échappent au contrôle du langage et reposent sur la seule vigilance du développeur... lequel se trompe parfois. Donc il est préférable de de pas y avoir recours quand c'est possible.

De plus, l'intérêt du C++ par rapport au C est justement l'apport de la programmation orientée objet et du formalisme qui l'accompagne, qui permettent d'éliminer les pointeurs du code produit autant que faire se peut. Bien sûr, il est important de connaître les pointeurs pour comprendre les mécanismes sous-jacents, mais hormis les deux cas de figure que je viens de citer, ces pointeurs peuvent ne plus apparaître dans les programmes si l'on utilise à fond le langage C++, en ne traitant plus les données qu'au travers des objets.

Si vous permettez, pourriez vous me donner un cours en C embarqué qui explique surtout les pointeurs (Vraiment ils sont difficiele !! ). par exemple l'explication du type: void* ....

Il me paraît difficile de donner un tel cours. Les forums ne sont pas prévus pour ça, vu que le sujet exigerait plusieurs dizaines de pages pour être traité convenablement. Et je me vois mal te conseiller tel ou tel cours ou tutoriel en ligne, vu que je ne les ai jamais lu (mes études et mon expérience professionnelle ont précédé l'ère Internet). Mais ça doit pouvoir se trouver à l'aide d'une recherche sur Google.

Je vais te donner quelques indications d'ordre général, mais au-delà, je pense qu'il serait préférable d'en rester à des questions portant sur des points précis.


Concernant les pointeurs, ce qu'il faut retenir, c'est que :

• Un pointeur est une variable qui contient une adresse en mémoire. Cette adresse est indéfinie tant qu'on ne l'a pas initialisée, et on peut la changer au cours du programme.

• La donnée située dans la mémoire à l'adresse contenue dans le pointeur est considérée comme une variable, et peut être manipulée comme telle par le programme. Pour ce faire, le type associé au pointeur définit le type de la variable pointée. Le type déclaré règle également le comportement des opérations sur le pointeur (par exemple l'incrémentation « ++ » ou la décrémentation « –– » - voir plus bas).

• La déclaration d'un pointeur s'effectue à l'aide de l'astérisque « * », précédée du type à lui associer : par exemple « char * p » définit la variable p comme un pointeur vers un char.

• Lorsque le type est a priori inconnu, on utilise le type void. Mais dans ce cas, avant de pouvoir manipuler la variable pointée, on doit définir son type à l'aide d'un cast (voir plus bas).

• Une fois qu'il a été déclaré, les utilisations possibles du pointeur sont :

1. l'assignation d'une adresse :
- « p = &a; » : la nouvelle valeur de p est l'adresse de la variable a en mémoire
- « p = q; » : la nouvelle valeur de p est la valeur de q (a priori, q doit être un pointeur contenant une adresse)
- etc. ...

2. l'accès à la variable pointée :
- « a = *p; » : la nouvelle valeur de a est la valeur actuelle de la variable pointée par p (attention: ici l'astérisque désigne le contenu de la variable pointée, ce n'est pas une déclaration de pointeur comme indiqué plus haut)
- « a = p[5]; » : la nouvelle valeur de a est la valeur actuelle de la sixième variable consécutive d'un tableau dont le début est pointé par p (« p[0] » représente le contenu de la première variable de ce tableau, et est équivalent à « *p »)
- « a = p->b; » : la nouvelle valeur de a est la valeur actuelle de l'élément b de la structure ou de l'objet pointé(e) par p (« -> » est l'équivalent du point « . » pour accéder à l'élément d'une structure ou d'un objet. « -> » est précédé du nom d'un pointeur, alors que « . » est précédé du nom d'une structure ou d'un objet)
- etc. ...

3. la manipulation du pointeur :
- « p++; » : incrémente le pointeur. La nouvelle adresse contenue dans p est l'adresse de la variable suivante dans le tableau de variables pointé par l'ancienne adresse de p. Par exemple, si p est un pointeur vers un float (type de variable qui occupe 4 octets en mémoire) alors l'opération ajoute 4 à l'adresse contenue dans p.
- « p += 3; » : incrémente le pointeur trois fois. La nouvelle adresse contenue dans p est l'adresse de la quatrième variable dans le tableau de variables pointé par l'ancienne adresse de p. Par exemple, si p est un pointeur vers un float, alors l'opération ajoute 3×4=12 à l'adresse contenue dans p. Elle est équivalente à « p = &p[3]; »
- etc. ...

4. la redéfinition par un cast
- « a = *(int *)p; » : en considérant momentanément le contenu de p comme l'adresse d'une variable de type int, on prend la valeur de cette variable pour la copier dans a
- « a = (int)*p; » : on lit la valeur de la variable pointée par p, puis l'on tente d'interpréter cette valeur comme un entier int afin d'en copier la valeur dans a. Le résultat peut être très différent de l'opération précédente, notamment si a et *p correspondent à des types dont la taille n'est pas identique.
- etc. ...

5. les actions conjuguées :
- « a = *++p; » : p est incrémenté, puis a prend la valeur de la nouvelle variable pointée par p
- « *p++ = *(q+=2); » : q est incrémenté deux fois, puis la variable pointée par p prend la valeur de la nouvelle variable pointée par q, puis p est incrémenté
- etc. ...

[narakphysics]

Re.
Votre explication est très claire .... Merci M. PASCAL

Parfois je trouve des écritures différentes : par exemple : char* tab et parfois char *tab;
quelle est la différence entre ces deux écritures?

[PA5CAL]

Il n'y a pas de différence. La présence de l'astérisque délimite déjà parfaitement les mots, et on peut rajouter des caractères d'espacement (espace, tabulation, saut de ligne) sans que cela change la syntaxe. On pourrait écrire :

char*tab;

mais aussi :

  char
*

        tab
 ;

[PA5CAL]

En fait, si l'on préfère mettre l'accent sur le fait que tab est de type « pointeur vers char », alors on écrit « char* tab; ». Et si l'on préfère mettre l'accent sur le fait que « *tab » pointe sur une variable de type char, alors on écrit « char *tab; ». C'est une question de point de vue, mais au fond c'est strictement la même chose.

[narakphysics]

En fait, si l'on préfère mettre l'accent sur le fait que tab est de type « pointeur vers char », alors on écrit « char* tab; ». Et si l'on préfère mettre l'accent sur le fait que « *tab » pointe sur une variable de type char, alors on écrit « char *tab; ». C'est une question de point de vue, mais au fond c'est strictement la même chose.

Ok, Donc c'est la même chose==>à retenir
Juste une information, le code que vous m'avez proposé, il marche bien maintenant (Sous ubuntu).
En ce qui concerne la structure, je l'ai modifié. En effet, j'ai pas pris en considération le "int bit" car j'ai plusieurs registres, en plus chaque registre contient 32 bits!! Donc c'est un peu pénible de déclarer tous les bits.
et pour accéder à n'importe quel bit, il suffit juste d'indiquer son numéro!! En revanche, cette solution exige une connaissance de tous les champs des registres!

[PA5CAL]

Si l'on constate ou si l'on s'astreint à certaines règle dans la façon de nommer les champs (répétitions, ordre alphabétique, etc.), il est certainement possible de remplacer tout ou partie de la table de recherche par du code et quelques fragments de tables.

Si les éléments sont nombreux ou susceptibles de changer souvent dans la vie du logiciel, alors il pourrait être intéressant de créer un programme qui génère automatiquement, à partir d'un seul fichier de description, d'une part le code source déclarant les structures, et d'autre part les tables et le code permettant d'associer les noms aux adresses (voire les adresses aux noms si cela présente une utilité).

[narakphysics]

Oui, je suis tout à fait d'accord avec vous.
Une autre question, Vu qu'elle est hors sujet [accéder à une structure C++], j'espère bien que le modérateur ne ferme pas cette discussion.
Question : Pourriez vous me donner un exemple pratique du mot clé volatile en C?

[PA5CAL]

Le mot clé volatile sert à empêcher le compilateur de modifier le programme par rapport au code. Cette modification est couramment pratiquée dans un but d'optimisation, mais cela peut modifier le fonctionnement du programme lorsque des événements inattendus (du moins pas visibles à la seule lecture du code) surviennent.

A priori, un programme écrit en langage C++ ne traite que les données déclarées et stockées en mémoire, et les modifications de ces données ne sont provoquées que par les instructions du programme.

Or, dans certains cas, cela n'est pas vrai.

Ainsi, lorsque le langage C++ est utilisé pour écrire un programme accédant aux registres d'un périphérique, les données traitées ne sont pas en mémoire, et elles peuvent être modifiées par le fonctionnement du matériel sans utiliser aucune instruction du programme. De même, lorsque plusieurs programmes tournent en parallèle (on parle de multi-threading), ils pourraient avoir la capacité de modifier une même donnée stockée en mémoire de façon indépendante et inopinée.


• Les données susceptibles de changer sans que le programme considéré n'intervienne doivent être déclarées comme volatile si l'on veut éviter que le compilateur les considère comme constante en l'absence d'instruction de modification.

Voici un exemple concret. Imaginons que la variable stop puisse être modifiée par la survenue d'un événement extérieur (par exemple l'appui sur un bouton d'arrêt) :

bool stop = false;

  while (stop==false) {
    avance_papier();
    descente_tampon();
    remontee_tampon();
 }

L'optimiseur du compilateur va remarquer que rien ne vient modifier la variable stop dans le programme, et considère à tort que « stop==false » est toujours vrai. Il va donc simplifier le test et supprimer la variable stop jugée inutile, en transformant le code exécutable comme si l'on avait écrit :

  while (true) {
    avance_papier();
    descente_tampon();
    remontee_tampon();
 }

En déclarant :

bool volatile stop = false;

on interdit au compilateur de faire ce type de modification.


• Un autre cas d'utilisation de volatile concerne le risque de voir modifier l'adresse d'une variable en mémoire.

Le langage C++ considérant a priori qu'il traite des données en mémoire et que tous les emplacements en mémoire se valent, le compilateur peut penser à tort qu'il peut les déplacer à sa convenance pour optimiser l'espace occupé. Or, lorsqu'un variable corresponde à un registre matériel, il est hors de question qu'il soit déplacé ailleurs qu'à l'endroit où le développeur l'a décidé.

Là encore, le mot clé volatile peut être utilisé pour empêcher ce type d'optimisation.