Coulée de type pointeur / adresse

J’ai les variables suivantes:

char *p; int l=65; 

Pourquoi les dissortingbutions suivantes échouent?

 (int *)p=&l; 

et:

 p=&((char) l); 

Le résultat de la conversion de type est toujours une valeur rvalue . Rvalue ne peut pas être assigné, c’est pourquoi votre première expression ne se comstack pas. Rvalue ne peut pas être pris adresse de, raison pour laquelle votre deuxième expression ne se comstack pas.

Pour effectuer la conversion de type correcte, vous devez procéder comme suit:

 p = (char *) &l; 

C’est la bonne façon de faire ce que vous avez essayé de faire dans votre deuxième expression. Il convertit int * pointeur en type char * .

Votre première expression est irréparable. Tu peux faire

 *(int **) &p = &l; 

mais ce qu’il fait finalement n’est pas vraiment une conversion , mais plutôt une réinterprétation de la mémoire occupée par char * pointeur en tant int * pointeur. C’est un bidouillage illégal et laid qui, la plupart du temps, a très peu de valeur pratique.

La bonne façon de faire cela serait:

 int I = 65; char* p = (char*)&I; 

&I vous donne un int* qui pointe vers I ; vous le convertissez ensuite en un caractère char* et l’assignez à p .

Notez que vous ne devriez pas normalement lancer entre des pointeurs de types non liés. Un caractère char* peut cependant être utilisé pour accéder à n’importe quel object. Dans ce cas particulier, il est donc sécurisé.

(int *) p = & l;

La ligne ci-dessus ne fonctionne pas, car dès que vous convertissez p en (int*) , le résultat est un object temporaire anonyme, qui est une valeur rvalue et non une valeur lvalue ; par conséquent, le résultat ne peut pas recevoir l’affectation, et même si la langue le permettait, vous affecteriez une copie moulée temporaire de p , et non pas à l’original p .

p = & ((car) l);

La ligne ci-dessus ne fonctionne pas pour une raison similaire; le résultat de (char) l est un object temporaire qui est une copie de l casté dans le type char. Par conséquent, comme il est temporaire, vous ne pouvez pas prendre son adresse.

Insead, vous pouvez utiliser:

 p = (char*) &l 

Le problème est que lorsque vous effectuez les conversions (en dehors de la question de savoir si le type de casting que vous réalisez est une bonne idée ou non), il en résulte que l’expression de la dissortingbution produit une valeur.

Les valeurs ne peuvent pas être atsortingbuées ou leurs adresses sockets.

En clair, ce qui n’est pas aussi ssortingct pour taper des conversions, ce code serait compilé et fonctionnerait. Sur un compilateur C ++, il faudrait en fait des conversions explicites, comme déjà mentionné (voir les autres réponses).