C++ de conversion de type avec des pointeurs

Dans les deux exemples que vous avez à faire des erreurs du code compile pas. Donc je vais supposer que vous essayez d'effectuer les opérations suivantes:

int x = 1;
char c = *((char*)&x);

En fonction de votre architecture, c auront désormais soit la valeur de la moins ou de l'octet le plus significatif de x. Dans cet exemple, ce serait soit de 0 ou de 1 (ce qui peut effectivement être utilisé pour détecter l'octet de commande).

Votre deuxième exemple ne fonctionnera pas, car vous êtes en essayant d'ignorer la const résultant en une opération illégale/mauvais cast (ce qui est aussi appelé "const correctness").

Edit: Concernant votre commentaire sur "ça veut dire quoi?":

Dans les expressions:
&somevariable sera de retour l'adresse de somevariable.
*somevariable assumera le contenu de somevariable sont l'adresse de la valeur réelle, qui est ensuite retourné.

Dans les déclarations:
datatype est une variable normale/objet. C'est passé "par valeur".
datatype& est une référence. Cela fonctionne exactement comme les variables normales en Java/C# et est passé par référence.
datatype* est un pointeur. Cette juste contient l'adresse où la valeur réelle est situé (voir ci-dessus) et est essentiellement transmis par référence.

Réelle jette travaillent à peu près similaire à Java/C#, mais les pointeurs sont ce qu'ils sont: Ils point à l'emplacement de la valeur réelle. Alors que l'on pourrait vous confondre, les pointeurs en C/C++ de travail à peu près comme les variables standard/références utilisées en Java/C#.

Regardez ceci:

MyClass x; //object of MyClass
MyClass *x; //pointer to an object of MyClass - the actual value is undefined and trying to access it will most likely result in an access violation (due to reading somewhere random).
MyClass *x = 0; //same as above, but now the default value is defined and you're able to detect whether it's been set (accessing it would essentially be a "null reference exception"; but it's actually a null pointer).
MyClass &x = MyClass(); //creating a new reference pointing to an existing object. This would be Java's "MyClass x = new MyClass();"

Il y a deux fondamentalement des concepts différents, en C++, qui sont parfois appelés "casting": l'Un est conversion, et on est réinterprétation.

Conversion crée un nouvel objet avec la "même valeur" comme un objet existant, mais d'un type différent. Voici quelques exemples:

Exemple 1: type de promotion

//1a: promote int to double to get the correct type of division

int numerator = rand(), denominator = rand();
double d = double(numerator) / double(denominator); 

//1b: convert int to double to achieve a particular argument deduction

int n;
template <typename T> void do_numeric_stuff(T x) { /* ... */ }

do_numeric_stuff(double(n));

Exemple 2: Dérivés à base de conversion

struct B { }; struct D : B { };
D x;

D * p = &x;  //pointer to x
B * q = p;   //implicit conversion; may change the value!

D'autre part, réinterprétation nous permet de traiter une variable comme si elle était une autre. Sur le seul bon et utile pour ce qui est sérialisation, sous une forme ou une autre.

Exemple 3: La Sérialisation

std::ofstream file("output.bin");    //output file
char large_buffer[HUGE];             //in-memory buffer

unsigned int n = get_data();

char const * p = reinterpret_cast<char const *>(&n);
file.write(p, p + sizeof n);                         //write the bytes of `n`
std::copy(p, p + sizeof n, large_buffer);            //ditto

std::copy(large_buffer + 17, large_buffer + 17 + sizeof n,
          reinterpret_cast<char *>(&n));   //repopulate `n` from buffer

La norme dit que c'est un comportement indéterminé d'accès à un objet par l'intermédiaire d'un pointeur qui n'est pas du bon type (également appelé "type beaucoup les jeux de mots"). Alors qu'il est OK pour stocker un pointeur d'objet, disons, d'un void* et puis le convertir en arrière et utiliser, il est pas OK pour traiter un flotteur comme s'il s'agissait d'un nombre entier, etc. Le seulement acceptable moyen d'accéder à un objet comme si c'était un autre est celui que j'ai démontré, à savoir le traitement d'un objet de type T comme si c'était un tableau char[sizeof(T)] — qui est, vous êtes autorisé à accéder au sous-jacente représentation binaire de chaque objet.

J'ai utilisé de nombreuses fois auparavant, qui s'attacha à l'accès MATÉRIEL à l'adresse indiquée, sur la coutume IO conseil d'administration. Ainsi, par exemple, pour écrire à PIC (programmable interrupt controller) pour réinitialiser certains drapeau (fictifs code):

#define PIC_LOC 0x1000
#define PIC_ENABLE_PORT *((char*)(PIC_LOC+0x10))
#define BIT_ENABLE (1 << 3)

...
PIC_ENABLE_PORT |= BIT_ENABLE;
...