Discussion :

[BaygonV]

Bonsoir,
je n'arrive pas a comprendre pourquoi

Code :

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

1
2
3
4
5
6
 
int main()
{
int A[10] = {0,1,2,3,4,5,6,7,8,9};
void* add = static_cast<void*>(A);
}

semble être légal (dixit g++).

Alors que

Code :

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

1
2
3
4
5
int main()
{
int A[10] = {0,1,2,3,4,5,6,7,8,9};
/*const*/ char* add = static_cast</*const*/ char*>(A);
}

ne l'est clairement pas (dixit g++).

je passe donc par

Code :

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

1
2
3
4
5
int main()
{
int A[10] = {0,1,2,3,4,5,6,7,8,9};
/*const*/ char* add = reinterpret_cast</*const*/ char*>(A);
}

il y a mieux ?

Je suis conscient que ce que je fais est borderline, c est juste un exercice.

[Bousk]

Bonsoir,

sais-tu à quoi sert le static cast ? Et ce que fait le reinterpret cast ?

Le static cast nécessite qu'il y ait un lien entre les types. A l'inverse du dynamic, il ne fait pas de test. Il faut l'utiliser quand tu es sûr du type réel de ta donnée.
Tout cast en void* est toujours faisable, c'est une sorte de "super"-type primitif.
Le reinterpret cast est lui aussi toujours possible, il ne change que la façon dont on voit les données, qui, elles, ne changent pas.

Tous les cast ont une utilité, et chacun a la sienne.

[BaygonV]

Pour moi :
- static_cast permet de rendre apparent des casts 'simples' type int vers long,int vers float ou (j'imagine) float vers double.
- static_cast permet d'eliminer les warnings lors de casts qui font perdre de l'information type long vers int ou int vers char.
- static_cast permet d'assigner un pointeur depuis un void*, permet aussi de transformer un pointeur de qqchose en pointeur de n'importe quoi.

Je pensais que puisqu'un pointeur est finalement une adresse qui dispose d'une arithmétique adaptée à la taille de l objet pointé, convertir un pointeur en pointeur d'autre chose revenait juste a signaler au compilateur que j'ai bien conscience que je vais changer d' arithmétique, vu que cette conversion peut (dans mon cas) se faire à la compilation j'imaginais donc que çà relevait du static_cast.

Finalement il semble que 'ma' facon de voir est erronée et que j'ai bien besoin d'un reinterpret_cast qui prend le 'bloc d'octets' d'un objet et le reformatte a la façon d'un autre objet quitte a perdre de l information ou a en gagner.

Le but de mon exo (dont je suis l'auteur, mais je pense bien qu'il a une solution) est de chercher a faire une fonction template

Code :

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

template<class T> string f(const T& O);

qui prenne un objet d'un type et renvoie un string contenant la representation bit a bit de l'objet en question.
Du coup je ne vois pas vraiment comment faire autrement que de decouper le bloc d'octets de mon objet en plein d'unsigned chars et pour ca je dois prelever l'adresse de O et pretendre que c'est l'adresse d'un const char.
Pour faire ca je vois deux manières (si ce que j'ai dit plus haut sur les utilisations de static_cast est vrai) :

Code :

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

1
2
 void* addv = static_cast<void*>(&O); 
const unsigned char* addc = static_cast<const unsigned char*> addv;

ou

Code :

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

1
2
 
const unsigned char* addc = reinterpret_cast<const unsigned char*>(&O);

Je pense tout haut au cas ou l'un d'entre vous ait l'envie et la patience de me corriger (pas trop fort svp ).
Je testerai demain ou ce soir beaucoup plus tard ces deux solutions (en fait j ai deja testé la deuxieme et elle semble marcher).