Discussion :

[Vorlaan]

Bonjour!

Après avoir relu les tutoriels du site, je n'ai pas trouvé de réponse. J'espère cependant ne pas poser une question idiote :p.

J'essaye de travailler sur une structure déclarée et définie dans une librairie dynamique (.so) par offset et pointeurs dans le programme "appelant", ce qui m'amène à un warning de g++. Le code est fonctionnel, mais pourriez vous m'indiquer une méthode équivalente qui ne fasse pas crier g++?

Ce que je fais est équivalent à:

la structure (.h):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
typedef struct
{
    float a;
    float b;
}dumbStruct;

le bout de code (.cpp)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
    void * ptr;
    dumbStruct Struc;
    Struc.a = 1;
    Struc.b = 2;
 
    ptr = &Struc;
    cout << "a :" << *(float*)ptr << "\n";
    cout << "b :" << *(float*)(ptr + sizeof(float)) << "\n\n";

Sortie:

a :1
b :2

La sortie est donc bonne, mais j'ai un warning de la forme:

attention : pointer of type ‘void *’ used in arithmetic [-Wpointer-arith]

Ok, donc il n'aime pas qu'on fasse de l'arithmétique avec un void *.....

Les casts sont simplement pour provoquer le warning (je pourrais ici juste déclarer le pointeur en float, ou enlever les parenthèses du cast, mais ça ne traduirait pas mon vrai soucis de ne pas connaitre le type du pointeur). En réalité, je dispose uniquement d'un pointeur void sur la structure, et d'un vector de strings contenant le type de toutes les variables (je peut donc gérer les offsets avec sizeof() qui accepte des strings en entrée). Je ne peut pas déclarer ou caster le pointeur dans le bon type pour éviter de travailler sur un void (enfin pas à ma maigre connaissance).


Pourriez-vous me proposer une alternative "propre" s'il vous plait? ( et donc qui ne fait pas pleurer gcc?)

Un grand merci d'avance!

[Médinoc]

Ah oui, le coup des pointeurs void. Le standard ne supporte pas ça (mais à mon opinion, devrait), gcc le supporte en tant qu'extension GNU...

Personnellement, je contourne le problème avec une fonction:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void* addoffset(void* pv, ptrdiff_t o)
{
	char * pby = pv;
	return pby + o;
}
 
void const * addoffsetC(void const * pv, ptrdiff_t o)
{
	char const * pby = pv;
	return pby + o;
}

[Bousk]

Salut,
tu peux garder le void*, mais pour éviter le warning il suffit de le caster en char* avant manipulation.
Ou directement en float* puisque tu le connais.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void * ptr;
    dumbStruct Struc;
    Struc.a = 1;
    Struc.b = 2;
 
    ptr = &Struc;
    // tout ce qui passe au-dessus n'est pas notre problème, on récupère un void*, on sait qu'il contient un dumbStruct donc on connait le contenu
    float* pF = reinterpret_cast<float*>(ptr);
    cout << "a :" << *pF << "\n";
    cout << "b :" << *(pF+1) << "\n\n";
    // il est encore plus simple de le caster directement dans notre structure
    dumbStruct* pStruct = reinterpret_cast<dumbStruct*>(ptr);
    cout<<"a : "<<pStruct->a<<endl<<"b : "<< pStruct->b<<endl<<endl;

[koala01]

Salut,

Le fait est que void est, normalement, le type utilisé pour présenter:

1. soit quelque chose d'inexistante( void foo() indique qu'il n'y a rien à renvoyer)
2. soit quelque chose de totalement indéfini lorsqu'il est utilisé comme pointeur (c'est un pointeur sur "quelque chose dont on ignore tout").

Un pointeur, ce n'est jamais qu'une adresse mémoire, et il n'y a strictement rien qui ressemble plus à une adresse mémoire... qu'une autre adresse mémoire, quel que soit le type de l'objet que l'on y retrouve

Si l'on connait la taille d'un objet se trouvant à une adresse particulière, on peut donc demander au compilateur d'aller voir ce qui se trouve à l'adresse mémoire utilisée par "ce qui suit" l'objet se trouvant à notre adresse particulière, mais cela reste, malgré tout, assez dangereux dans le sens où ce n'est pas parce que l'on sait ce qui se trouve à l'adresse A que l'on sait forcément ce qui se trouve à l'adresse A + (taille de l'objet se trouvant à l'adresse A).

L'avertissement que tu obtiens t'incite donc tout simplement à te méfier de l'arithmétique des pointeurs parce que tu effectue un transtypage "brutal" de ce qui se à une adresse calculée, et que le compilateur "est obligé" de te faire confiance, sans aucun moyen de vérifier que ce que tu lui dit ("l'adresse ptr+ taille d'un float doit être considérée comme l'adresse d'un float") est effectivement correct.

L'idéal est donc d'abandonner ton void* "aussi vite que possible" au profit d'un pointeur sur la structure effectivement utilisée, et de préférer par la suite accéder "simplement" aux éléments de cette structure par les noms qui en représentent les différents champs

[Vorlaan]

merci pour vos réponses! Et pour avoir pris le temps d'expliquer

C'est maintenant clair, je vais tenir compte de tout ça!