Puntero / tipo de dirección de fundición

Tengo las siguientes variables:

char *p; int l=65; 

¿Por qué fallan los siguientes moldes?

 (int *)p=&l; 

y:

 p=&((char) l); 

El resultado de la conversión de tipo es siempre un rvalue . No se puede asignar un valor, por lo que su primera expresión no se comstack. No se puede tomar la dirección de valor, por lo que la segunda expresión no se comstack.

Para realizar la conversión de tipo correcta, debe hacerlo de la siguiente manera

 p = (char *) &l; 

Esta es la forma correcta de hacer lo que intentaste hacer en tu segunda expresión. Convierte int * puntero a tipo char * .

Tu primera expresión está más allá de la reparación. Tu puedes hacer

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

pero lo que hace al final no es realmente una conversión , sino la reinterpretación de la memoria ocupada por el puntero char * como puntero int * . Es un truco ilegal y feo que la mayoría de las veces tiene muy poco valor práctico.

La forma correcta de hacer esto sería:

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

&I te da un int* que apunta a I ; luego, le asignas esto a un char* y lo asignas a la p .

Tenga en cuenta que normalmente no debe realizar la conversión entre punteros de tipos no relacionados. Sin embargo, se puede usar un char* para acceder a cualquier objeto, por lo que en este caso particular es seguro.

(int *) p = & l;

La línea de arriba no funciona, porque tan pronto como lanzas p a (int*) , el resultado es un objeto temporal anónimo, que es un valor de r, y no un valor de l ; por lo general, el resultado no puede recibir la asignación, e incluso si el idioma lo permitiera, estaría asignando una copia temporal de p , no a la p original.

p = & ((char) l);

La línea de arriba no funciona por una razón similar; el resultado de (char) l es un objeto temporal que es una copia de l emitida al tipo char. En consecuencia, debido a que es temporal, no puede tomar su dirección.

Insead, puedes usar:

 p = (char*) &l 

El problema es que cuando estás realizando los lanzamientos (aparte de si el tipo de lanzamientos que estás haciendo es una buena idea o no) es que la expresión de los emitidos da como resultado un valor de r.

Los valores no se pueden asignar o se pueden tomar sus direcciones.

En el plano C, que no es tan estricto para escribir conversiones, este código comstackría y realmente funcionaría. En un comstackdor de C ++ realmente requeriría conversiones explícitas como ya se mencionó (ver otras respuestas).