Discussion :

[ShaiLeTroll]

Je m'interroge sur le cast du C++

J'ai lu
Cours C - II-B-12. Conversion de type (\cast" operator)
FAQ C++ - Comment effectuer une conversion de type explicite (cast) ?

Je me suis aperçu d'une complexité syntaxique du C++ lors de l'utilisation TSmallPoint est la méthode Delphi équivalent à la Macro MAKEPOINTS pour utiliser une message type WM_MOUSEMOVE, WM_LBUTTONUP ... via SendMessage avec le TSmallPoint dans lParam

Voici un code d'exemple en C++

Code c++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
{
  TSmallPoint SP;
  SP.x = 1;
  SP.y = 1;
  int i ;
 
  Perform(WM_MOUSEMOVE, 0, *((int*)(&SP))); // C'est Effrayant de complexité !
 
//    i = SP; // Ne Compile pas ! Normal !
//    i = (int)SP; // Ne Compile pas ! Pourquoi ?
//    i = *((int*)(&SP)); // Compile et Fonctione ! Mais c'est illisible !
//    i = reinterpret_cast<int>(SP); // Ne Compile pas ! Pourquoi ?
    i = reinterpret_cast<int&>(SP); // Compile et Fonctione ! Mais c'est long et pourquoi & ? Cela revient à écrire la ligne au dessus !
 
  ShowMessage(i);
 
  TPoint P;
  P.x = 1;
  P.y = 1;
  double D;
 
  // D = (Double)P; // Ne Compile pas ! Pourquoi ?
  D = *((double*)(&P)); // Compile et Fonctione ! Mais c'est illisible !
  ShowMessage(D);
 
  i = D + 1; // C++ converti le double en int sans broncher !
  ShowMessage(i);
}

Voici l'équivalent Delphi !
Alors que Delphi est nettement plus strict au niveau des conversions entre entier et flottant ou la conversion vers une chaine, il accepte des transtypages sur des types de même longueur que n'accepte pas le C++ !

Code Delphi :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
var
  SP: TSmallPoint;
  I: Integer;
  D: Double;
  P: TPoint;
begin
  SP.x := 1;
  SP.y := 1;
 
  Perform(WM_MOUSEMOVE, 0, Integer(SP)); // Simple et Efficace
 
  I := Integer(SP);
  ShowMessage(IntToStr(I));
 
  P.x := 1;
  P.y := 1;
  // D := Double(SP); // E2089 Transtypage Incorrect - normal Double est sur 8 octets et TSmallPoint sur 4
 
  D := Double(P); // Même Taille ! Donc OK !
  ShowMessage(FloatToStr(D));
 
  // i := D + 1; // E2010 Types incompatibles - Double et Integer c'est pas la même chose !
  i := Trunc(D + 1); // Trunc, Floor, Ceil, on doit fournir une méthode de conversion explicite !
  ShowMessage(IntToStr(I));
 
end;

Je termine tout de même par une question :
Existe-t-il quelque chose de plus concis que reinterpret_cast<int&>(SP) ou i = *((int*)(&SP)) ?

[DjmSoftware]

Salut
La syntaxe correcte dans le cas d'un cast de type et non de pointeur sur un type serait dans le cas de figure:
pour autant que je souvienne en Delphi on travaille avec des références
--> (integer) SP = en C++ (int&)SP

Code :

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

1
2
3
4
5
6
 
 
 Perform(WM_MOUSEMOVE, 0, (int&)SP)
 
// et
D = (double&)P;

cdlt

[blondelle]

Salut ShaiLeTroll
Voici un lien vers un tuto sur le sujet, j'espere que cela va pouvoir t'aider

http://www.bogotobogo.com/cplusplus/typecast.html

[ShaiLeTroll]

Merci DjmSoftware !
Tout simplement i = (int&)SP;, c'est vrai que reinterpret_cast se fait aussi sur int& et non sur int, je ne sais plus où j'ai trouvé l'idée de l'écrire comme cela !

en Delphi, les types simples comme int ou double, c'est une allocation statique normal, il n'y a pas de référence,
il est juste capable de transtyper de deux types de la même taille !
Par contre, les TObject sont implicitement des références
Obj: TObject correspond à TObject* Obj,
Obj: ^TObject correspond à TObject** Obj.
Le type string aussi est assez subtile dans sa gestion interne

@blondelle, dommage, je l'ai lu aussi celui là !

The syntax is:

reinterpret_cast < type-name > (expression)

Quand je lit ça, j'écris naturellement

Code :

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

reinterpret_cast < int > (expression)

et pas

Code :

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

reinterpret_cast < int & > (expression)

Dans l'instruction reinterpret_cast< T > (arg), T doit être un pointeur, une référence, un type arithmétique, un pointeur de fonction ou un pointeur de membre.

un type arithmétique ? int c'est pas le type arithmétique par excellence ?

J'ai trouvé d'autres documentations

The reinterpret_cast operator allows any pointer to be converted into any other pointer type. It also allows any integral type to be converted into any pointer type and vice versa. Misuse of the reinterpret_cast operator can easily be unsafe. Unless the desired conversion is inherently low-level, you should use one of the other cast operators.

Je n'avais pas pigé la subtilité de cette phrase !