Passage par adresse de paramètre dans une fonction, un doute me taraude...

[mweber]

Bonjour à tous

J'ai un petit problème avec le passage par adresse dans une fonction écrite en langage C (pour microcontrôleur PIC 8 bits (Ça reste du C, sauf que les short sont sur 8 bits)).

Je désire (à ma fonction) lui passer différent types: entier signés 16 bits, entier signés 8 bits pour qu'elle modifie la valeur.


Voici un exemple tout bête :

void Ma_fonction(int* _x)           // Ajoute 10 à la valeur passée en argument
  {
  *_x =  *_x  + 10 ;
  }

void main(void)
{
int     a = 20;      // Entier codé sur 16 bits
short b = 30;      // Entier codé sur 8 bits

Ma_fonction(&a);
Ma_fonction(&b);
Afficher a;
Afficher b;
}

A la compil j'ai un "suspicious pointer conversion" pour Ma_fonction(&b);
...Qui peut être supprimé en remplaçant la ligne par: Ma_fonction((int*)&b);

Mais j'ai un comportement erratique: la fonction marche bien pour les appels de Ma_fonction(&a);
mais pas pour les appels de Ma_fonction(&b); Ça marchouille genre symptômes écrasements mémoire

Pourquoi ? Car pour moi, la taille des pointeurs est la même, quel que soit leur type (char*, int*...) car une adresse reste une adresse

Et comment résoudre ce problème, sans créer une seconde fonction pour traiter les shorts... et sans modifier toutes mes déclarations de variables short en int... (mémoire ROM et EEPROM limitée pour stocker plus de 50 paramètres)

Merci pour vos lumières !!

Matthieu
-----

[invite936c567e]

Bonjour

]

short b = 30;      // Entier codé sur 8 bits

Si tu passes un pointeur sur un octet à une fonction pour faire une addition sur 16 bits, alors tu vas modifier l'octet placé à l'adresse suivant cet octet, et donc altérer le contenu de la mémoire.

Il est donc normal :
- que le compilateur te mette en garde à propos du type déclaré,
- que le programme puisse montrer des dysfonctionnements.

[mweber]

Ok merci, c'est bien ce que je pensais; mais.. dans la mesure ou mon addition ne dépasse pas 0xFF, je pensais que l'octet jouxtant le 1er ne serait pas altéré... nan en fait c'est logique !!

Comment résoudre le problème ?

Merci

[invite936c567e]

Eh oui. 0xFF sur 16 bits, c'est 0x00FF, d'où l'écrasement de l'octet de poids fort par un zéro.


La finalité du typage des variables en C est justement de détecter (ce qui est fait ici) et/ou d'interdire ce cas de figure.

En langage C, il n'est pas possible de créer une seule fonction qui fasse tantôt une opération, tantôt une autre (l'addition sur 8 bits et l'addition sur 16 bits étant clairement différentes), au gré du type du paramètre qui lui est passé.

Si tu ne peux pas passer tes short en int, je ne vois pas d'autre moyen que de créer deux fonctions et de modifier ton programme à la main pour utiliser celle qu'il faut dans chaque cas. Les messages (erreurs ou warnings) générés à la compilation devraient pouvoir t'aider dans ce travail.

[A voir en vidéo sur Futura]

[invite936c567e]

Si le but est d'effectuer des traitements sur des éléments dont la nature est variable et n'est pas connue au moment de la compilation (on a alors affaire à une programmation orientée objet), il te faudrait passer un paramètre supplémentaire à la fonction afin d'identifier le type de l'élément traité et de réaliser l'opération adéquate.

Par exemple :

void Ma_fonction(void *x, unsigned char t)
{
  if (t==1)
    *(char *)x += 10;
  else
  if (t==2)
    *(int *)x += 10;
}

#define MA_FONCTION(v) Ma_fonction(&(v), sizeof(v))

...

int a;
char b;

MA_FONCTION(a); // addition sur 16 bits
MA_FONCTION(b); // addition sur 8 bits

Toutefois, cette solution présente de nombreuses limites et un coût en termes de ressources et de performances ...

[mweber]

Merci !

Plutôt que de créer 2 fonctions a peu près identiques je peux faire un truc du genre :

void Ma_fonction(int* _x, short* _y)           // Ajoute 10 à la valeur passée en argument
  {
  if (_x != 0) {printf(" [%d] ", *_x + 11) ; *_x+= 3; }
  if (_y != 0) {printf(" [%d] ", *_y + 15) ; *_y+= 4; }
  
      
  }

void main(void)
{
int   a = 10;      // Entier codé sur 16 bits
short b = 30;      // Entier codé sur 8 bits


Ma_fonction(&a, 0);
Ma_fonction(0, &b);

printf("%d %d", a, b);
}

Matthieu

[mweber]

Merci pour les balises "codes"

Bizarrement la mise en forme (police et autre) n'apparait plus dans mon navigateur Firefox pour le forum... ! Je n'ai que les smileys

Matt

[JPL]

Vide le cache de ton navigateur (si tu utilises Firefox ce n’est pas instantané) et recharge la page.

[jacknicklaus]

tu peux aussi définir l'usage de ta fonction via une macro qui va te calculer automatiquement le deuxième argument par une fonction sizeof()

#define Ma_fonction(a) \
FonctionDeux(&a,sizeof(a));


void FonctionDeux(void * _x, int _size) 
{
  if (_size == 2) (int*)_x += 10;
  else if (_size == 1 )  (short*)_x += 10;  
}

void main(void)
{
int   a = 10;      // Entier codé sur 16 bits
short b = 30;      // Entier codé sur 8 bits


Ma_fonction(a);
Ma_fonction(b);
}

code éventuellement à tuner, pas de moyen de tester ce moment.

[mweber]

Ah oui ! Jolis !

Merci

Matthieu

[pm42]

Ah oui ! Jolis !

Pas vraiment. On perd le typage, cela suppose que la taille d'un int est 2 et celle d'un short est 1 ce qui n'est pas garanti...
Par exemple, sur ma machine (et sur de nombreuses autres), la taille d'un short est 2 et celle d'un int est 4.

Donc le jour où tu passes ton code sur un micro-controlleur 32 bits, ça ne marche plus.

[jacknicklaus]

On perd le typage, cela suppose que la taille d'un int est 2 et celle d'un short est 1 ce qui n'est pas garanti...

effectivement. Mais le cahier des charges précisait : "(pour microcontrôleur PIC 8 bits (Ça reste du C, sauf que les short sont sur 8 bits))."


Celà dit, c'est facile de conserver le typage :

  if (_size == sizeof(int)) (int*)_x += 10;
  else if (_size == sizeof(short) )  (short*)_x += 10;

[pm42]

Oui, je ne dis pas que c'est le truc le pire qu'on puisse faire, juste que ce n'est pas forcément à prendre tel quel comme exemple quand on est débutant.
Ceci dit, j'ai du mal à voir l'intérêt d'écrire du code compliqué pour tout mettre dans 1 seule fonction au lieu d'en faire 2.

D'autant qu'on peut faire une macro pour faire l'ajout de 10 et qui fonctionnera pour tous les types.

[invite936c567e]

tu peux aussi définir l'usage de ta fonction via une macro qui va te calculer automatiquement le deuxième argument par une fonction sizeof()

#define Ma_fonction(a) \
FonctionDeux(&a,sizeof(a));


void FonctionDeux(void * _x, int _size) 
{
  if (_size == 2) (int*)_x += 10;
  else if (_size == 1 )  (short*)_x += 10;  
}

void main(void)
{
int   a = 10;      // Entier codé sur 16 bits
short b = 30;      // Entier codé sur 8 bits


Ma_fonction(a);
Ma_fonction(b);
}

code éventuellement à tuner, pas de moyen de tester ce moment.

Heu... C'est la solution que j'avais déjà donnée au post #5... et que j'avais testée.

[albanxiii]

Heu... C'est la solution que j'avais déjà donnée au post #5... et que j'avais testée.

Vous n'aviez jamais remarqué que beaucoup répondent sans avoir lu le réponses déjà données ?

[jacknicklaus]

Heu... C'est la solution que j'avais déjà donnée au post #5... et que j'avais testée.

oups !
désolé

[mweber]

Bon en tout cas merci pour vos idées.

Je ne pouvais par contre pas créer 2 fonctions car elle est bien plus complexe en réalité...
Même en factorisant des parties j'étais perdant en ROM par rapport aux soluces proposées

Bon je suis un tantinet taré de coller dans un PIC à 64 ko de ROM, la gestion d'un poêle à pellet + panneau solaire thermique + chauffage avec écran tactile couleur carte SD et Wifi !

Sans y aller avec une Raspberry PI, une Arduino méga avec un shield fait maison aurait été..

Mais n'en'pêche tout mon programme tient dans les 64 ko !

Matt