accéder à une structure [C++]

[Jack]

Pourriez vous me donner un exemple pratique du mot clé volatile en C?

Puisque tu as l'air de t'intéresser à l'embarqué, si tu programmes bas niveau, c'est à dire la couche traitant des registres du processeur, il faut parfois faire de trucs qui à priori ne servent à rien d'un point de vue algorithmique, comme lire un registre, ou un bit de regsitre pour réinitialiser la fonction qui lui correspond.
On pourrait donc trouver des lignes du genre:

 Reg1;
Adc.bit

où reg1 correspond à un registre et Adc.bit à un bit du registre Adc.

Le compilateur peut être amené à supprimer cette ligne car il n'y voit aucun intérêt, ne connaissant rien au hardware du processeur.

Autre raison, en multiprocessing, la variable pourrait être modifiée par un autre processus. Lire une variable plusieurs fois dans un processus sans en modifier le contenu pourrait amener le compilateur à ne conserver qu'une seule lecture alors qu ces lecture pourraient avoir un sens si l'autre processus venait à modifier le contenu de la variable.

Le qualificateur volatile empêche donc le compilateur de faire des optimisations sur la variable en question.

A+

PS: je vois que PA5CAL est passé par là
-----

[invitefa15af9f]

Merci à tous PASCAL et JACK de vos réponses
Franchement c'est la première fois que je comprend le mot clé volatile ..
C'est pourquoi par exemple dans le logiciel MicroC, lorsqu'on compile un programme, en bas il désigne qu'il y a des variables non utilisées et les supprime afin d'optimiser le code....

Dans mon programme, je désire lister les variables globales sans accéder aux fichiers sources .c, la solution que j'ai adopté est d'interpréter le fichier map et voir la secion .bss qui contient les variables globales non initialisées. Est ce la bonne solution ??

[Jack]

Dans mon programme, je désire lister les variables globales

Je ne saisis pas trop la finalité de la chose ...

[invitefa15af9f]

Merci M. Jack de votre réponse

[Jack]

Il s'agissait plus d'une interrogation que d'une réponse. Quel est le but du listing des variables globales?

[invitefa15af9f]

Re.

Quel est le but du listing des variables globales?

Pour les modifier.

[Jack]

Mais pourquoi tu ne veux pas passer par le source?

[invitefa15af9f]

En fait, je suis entrain de réaliser une interface graphique simple permettant d'accéder aux variables globales du programme chargé dans un µC à travers un simulateur.
Cette interface peut accéder aux différentes adresses à partir d'une API de cet émulateur.
Supposons que je connais pas les noms des variables globales. donc je peux lister ces variables sur l'interface au lieu d'accéder aux différents fichiers headers et voir leurs déclaration...

[Jack]

Et comment comptes-tu savoir quel type de variables sont mémorisées si tu n'as pas le source? Comment vas-tu par exemple savoir si 4 octets consécutifs représentent 2 "shorts" ou un "int" par exemple?

[invitefa15af9f]

Dans le fichier Map il y a 3 colonnes : input section , virtual adress et size
donc à partir de size je peux connaitre le type de la variable. est ce juste ?

[Jack]

Ah, tu as ce genre de fichier à ta disposition!

Donc en fait ton appli va effectivement pouvoir puiser les infos dans ce fichier. reste à en connaitre le type si tu veux en afficher la valeur

[invitefa15af9f]

Si par exemple j'ai une variable de type unsigned int. Je crois pas que je serai capable d'en déduire car aussi signed int est codé sur le même nombre de bit !!!

[Jack]

Si par exemple j'ai une variable de type unsigned int. Je crois pas que je serai capable d'en déduire car aussi signed int est codé sur le même nombre de bit !!!

Je ne comprends pas. Imaginons que le fichier map indique qu'une variable occupe 4 octets. Comment vas-tu savoir s'il s'agit d'un int, d'un unsigned int ou d'un float?

[invitefa15af9f]

Je ne comprends pas. Imaginons que le fichier map indique qu'une variable occupe 4 octets. Comment vas-tu savoir s'il s'agit d'un int, d'un unsigned int ou d'un float?

Franchement je sais pas!!
c'est impossible si je connais pas d'avance le type?

[Dlzlogic]

Bonjour,
J'ai un peu de ma à comprendre où vous voulez en venir.
Je résume : vous cherchez à afficher {?} des variables globales.
Par définition vous connaissez leur nom. Mon compilateur met un '_' devant, mais ça ne change rien.
Soit la variable "espion" (pour moi, il s'agit d'un FILE*, donc d'un pointeur sur structure).
Si je veux obtenir la valeur de l'un des termes de la structure, par exemple "bsize", je sais que c'est un int, alors je vais faire print( "%d",espion->bsize);
Si je veux l'adresse de cette valeur, je vais faire
print(" %p",&espion->bsize); (syntaxe à vérifier).
Sans un programme 'C' on peut toujours savoir la valeur d'une variable et son adresse.
Mais sauf en debug, je vois pas très bien l'utilité.
Personnellement, je n'utilise la map qu'en dernier recours.

[Dlzlogic]

Bonjour,
J'ai un peu de ma à comprendre où vous voulez en venir.
Je résume : vous cherchez à afficher {?} des variables globales.
Par définition vous connaissez leur nom. Mon compilateur met un '_' devant, mais ça ne change rien.
Soit la variable "espion" (pour moi, il s'agit d'un FILE*, donc d'un pointeur sur structure).
Si je veux obtenir la valeur de l'un des termes de la structure, par exemple "bsize", je sais que c'est un int, alors je vais faire print( "%d",espion->bsize);
Si je veux l'adresse de cette valeur, je vais faire
print(" %p",&espion->bsize); (syntaxe à vérifier).
Sans un programme 'C' on peut toujours savoir la valeur d'une variable et son adresse.
Mais sauf en debug, je vois pas très bien l'utilité.
Personnellement, je n'utilise la map qu'en dernier recours.

[invitefa15af9f]

Merci Dlzlogic de votre réponse

....je sais que c'est un int, alors je vais faire print( "%d",espion->bsize)

Comment connaissez vous le type???

[invite936c567e]

narakphysics cherche à fournir à l'utilisateur la valeur des variables qu'il réclame.

Or, pour que l'utilisateur puisse obtenir la variable demandée au moment où le programme est exécuté, le nom doit être donné d'une manière ou d'une autre par le programmeur avant la compilation ou l'édition de lien de ce programme. Il y a un problème évident de chronologie. Pour que le programmeur puisse écrire « print( "%d",espion->bsize); », il faut qu'il devine qu'à cet endroit du programme l'utilisateur réclamera la valeur de bsize.

Si l'« on » peut toujours connaître la valeur et l'adresse d'une variable dans un programme C, en revanche ce n'est pas n'importe quand, ni par n'importe qui, ni dans n'importe quelle situation. Le programmeur connaît le nom et le type de la variable, mais normalement pas son adresse. Le programme exécuté connaît l'adresse de la variable mais a normalement oublié son nom.

Ici, il faut que le programme puisse, à partir du nom fourni au moment de son exécution, retrouver et traiter correctement la variable correspondante (autrement dit retrouver son adresse et son type). L'association entre le nom et la variable (adresse+type) doit donc être présente dans le code exécutable, sous forme de donnée ou d'algorithme.

NB: pour « print( "%d",espion->bsize); », la syntaxe est juste, mais l'adresse de la variable n'a pas d'utilité pour l'utilisateur du programme.

[invite936c567e]

Pour répondre à la question, l'utilisation d'un fichier de « map » me paraît être un pis-aller, puisque cela suggère de :
- commencer par écrire le programme, et à un moment on dispose déjà des noms et des types,
- lancer une compilation pour obtenir une liste qui n'est pas directement exploitable (il faut la trier, les noms sont augmentés d'un préfixe "_", on n'a pas le type mais la taille, on a une adresse mais pas nécessairement celle utilisée au final),
- continuer d'écrire le programme avec les informations récupérées
- terminer par une compilation (éventuellement partielle) et une édition de liens (complète).

Il me semble beaucoup plus efficace et moins risqué de :
- commencer par écrire entièrement la liste de noms et de types,
- générer automatiquement ou implicitement à partir de cette liste le code nécessaire à la déclaration des variables et à la recherche et au traitement de ces variables à partir de leur nom,
- terminer par une compilation et une édition de liens, uniques et complètes.

[invitefa15af9f]

Pour répondre à la question, l'utilisation d'un fichier de « map » me paraît être un pis-aller, puisque cela suggère de :
- commencer par écrire le programme, et à un moment on dispose déjà des noms et des types,
- lancer une compilation pour obtenir une liste qui n'est pas directement exploitable (il faut la trier, les noms sont augmentés d'un préfixe "_", on n'a pas le type mais la taille, on a une adresse mais pas nécessairement celle utilisée au final),
- continuer d'écrire le programme avec les informations récupérées
- terminer par une compilation (éventuellement partielle) et une édition de liens (complète).

Oui j'ai bien saisi l'inconveinient de telle méthode.

Il me semble beaucoup plus efficace et moins risqué de :
- commencer par écrire entièrement la liste de noms et de types,
- générer automatiquement ou implicitement à partir de cette liste le code nécessaire à la déclaration des variables et à la recherche et au traitement de ces variables à partir de leur nom,
- terminer par une compilation et une édition de liens, uniques et complètes.

Cette méthode requiére une connaissance au préalable du contenu du programme. n'est ce pas?

[Dlzlogic]

narakphysics cherche à fournir à l'utilisateur la valeur des variables qu'il réclame.

Or, pour que l'utilisateur puisse obtenir la variable demandée au moment où le programme est exécuté, ...

Je vais prendre un exemple simple : un programme qui calcule l'aire d'un rectangle.
L'informaticien a prévu dans son programme 2 variables qu'il a appelées "width" et "height", ça fait plus joli et ça n'a aucune importance width est en double et heignt en float, pourquoi pas.
Puis il y aura une variable nommée area et la fonction CalcAire(); (évidemment, puisque les variables sont globales).

Il apparait que l'utilisateur voudrait "connaitre" les variables par leur nom. Par exemple le rectangle sera défini par "longueur" et "largeur". Et le résultat par "Aire". l'utilisateur a donné une valeur à ces variables, il obtient une superficie, il est content.
Cependant, il veut modifier la longueur, mais il ne sait plus quelle valeur il lui a donné.
Alors if va faire
longueur = ?
et il aura la valeur de la longueur.
etc.

Ce que je veux dire par cet exemple est qu'il ne faut pas voir le problème vis à vis de l'informaticien, mais par rapport à l'utilisateur. Si l'utilisateur a besoin de renseignements sur une variable définie par son nom, c'est qu'il connait ce nom. Soit il est imposé par le logiciel, par exemple, ce sera "width" et "height", soit donné par l'utilisateur. Dans les deux cas, ce nom, une chaine, devra être défini explicitement, soit lors de la compile, soit comme variable. Le type sera forcément rattaché à la variable elle même, il sera consultable ou non, mais forcément connu par le programme.

Dans la pratique, le plus simple me parait être de faire une structure qui pourrait être

typedef struct VARIABLE
{
  char Nom[10];  // 9 caractères maximum
  int type; // avec un système ce codage 0:int 1:float 3:double etc.
  union
  {
//  ... je sais plus la syntaxe
  }  
}Variable;

Certaines variables pourraient avoir des noms imposés par l'informaticien, d'autres à la discrétion de l'utilisateur.

[invite936c567e]

Cette méthode requiére une connaissance au préalable du contenu du programme. n'est ce pas?

Seulement des variables connues de l'utilisateur, et c'est justement ce qu'on définit dans la première étape.

Sinon, il y a la possibilité de rendre le comportement du programme entièrement dynamique, en n'utilisant que des informations fournies après-coup par l'utilisateur. Mais ça n'a d'intérêt que si l'utilisateur souhaite en changer.

[invite936c567e]

Dans les deux cas, ce nom, une chaine, devra être défini explicitement, soit lors de la compile, soit comme variable. Le type sera forcément rattaché à la variable elle même, il sera consultable ou non, mais forcément connu par le programme.

C'est ce que j'avais expliqué, d'une autre façon, en insistant sur le fait que le programme (et non le compilateur) doit connaître le nom de la variable, c'est-à-dire sous forme de chaîne de caractères.

Certaines variables pourraient avoir des noms imposés par l'informaticien, d'autres à la discrétion de l'utilisateur.

Pourquoi pas, en effet.

Et les méthodes que j'ai données ci-dessus le permettent.

[Dlzlogic]

En fait tout revient à écrire un logiciel de langage interprété, avec la nuance éventuelle que le nom de certaines variables ou de la totalité sont des noms imposés.
Les logiciels de gestion de devis sont à peu près basés sur ce principe.
Mais je suis entrain de me demander si on ne cherche pas le "moyen de la faire" avant de définir ce que l'on veut faire.
@ PASCAL oui, je crois que nous sommes complètement d'accord

[invite7a96054d]

Bonjour,

juste pour que ce soit clair dans mon esprit, @narakphysics : si je comprends bien, tu as un simulateur de plateforme embarquée que tu peux piloter via une API.
Tu as un programme que tu compiles que tu charges dans le simulateur et un programme que tu as écris accède au simulateur.
Par curiosité peux-tu compiler le programme simulé avec des options de débogage ? ces données de débogages peuvent-elles être accédées via l'API ?

[invite936c567e]

Cette méthode requiére une connaissance au préalable du contenu du programme. n'est ce pas?

Pour éviter toute confusion, je précise qu'on peut parfaitement remplir la liste en même temps qu'on code le programme.

Si l'on doit utiliser une variable dans le programme, c'est parce qu'on la connaît. Et on doit la déclarer. S'il s'agit d'une variable rendues accessibles à l'utilisateur, il suffit de l'ajouter à la liste. La génération automatique du code à partir de la liste peut se faire au dernier moment, après avoir terminé d'écrire le reste du programme.

[invitefa15af9f]

Merci Kwariz de votre réponse

Bonjour,

juste pour que ce soit clair dans mon esprit, @narakphysics : si je comprends bien, tu as un simulateur de plateforme embarquée que tu peux piloter via une API.
Tu as un programme que tu compiles que tu charges dans le simulateur et un programme que tu as écris accède au simulateur..

Oui , exactement, j'aimerai bien contrôler mon simulateur à travers d'une API.

Par curiosité peux-tu compiler le programme simulé avec des options de débogage ? ces données de débogages peuvent-elles être accédées via l'API?? .

Oui je peux compiler le programme avec des options de débogage mais, je peux pas accéder à ces données.

[invite7a96054d]

[...]
Oui , exactement, j'aimerai bien contrôler mon simulateur à travers d'une API.
Oui je peux compiler le programme avec des options de débogage mais, je peux pas accéder à ces données.

Tu as écris toi-même le simulateur ?

[invitefa15af9f]

Tu as écris toi-même le simulateur ?

Non.
Juste je voudrai utiliser toutes les fonctionnalités de ce simulateur à partir d'une autre interface graphique!

[invite7a96054d]

OK et ce simulateur a une API publique ? D'ailleurs quel est ce simulateur que tu utilises ?