Pensar en C++ (Volumen 1) - Grupo ARCO

✐
✐
✐
“Volumen1” — 2012/1/12 — 13:52 — page 106 — #144
✐
Capítulo 3. C en C++
// (3) Forcing a conversion from void* :
void* vp = &i;
// Old way produces a dangerous conversion:
float* fp = (float*)vp;
// The new way is equally dangerous:
fp = static_cast(vp);
// (4) Implicit type conversions, normally
// performed by the compiler:
double d = 0.0;
int x = d; // Automatic type conversion
x = static_cast(d); // More explicit
func(d); // Automatic type conversion
func(static_cast(d)); // More explicit
} ///:~
En la sección (FIXME:xref:1), se pueden ver tipos de conversiones que eran usuales
en C, con o sin un molde. Promover un int a long o float no es un problema porque
el último puede albergar siempre cualquier valor que un int pueda contener. Aunque
es innecesario, se puede utilizar static_cast para remarcar estas promociones.
Se muestra en (2) como se convierte al revés. Aquí, se puede perder información
porque un int no es tan «ancho» como un long o un float; no aloja números
del mismo tamaño. De cualquier modo, este tipo de conversión se llama conversión
de estrechamiento. El compilador no impedirá que ocurran, pero normalmente dará
una advertencia. Se puede eliminar esta advertencia e indicar que realmente se
pretendía esto utilizando un molde.
Tomar el valor de un void* no está permitido en C++ a menos que use un molde
(al contrario de C), como se puede ver en (3). Esto es peligroso y requiere que los
programadores sepan lo que están haciendo. El static_cast, al menos, es mas
fácil de localizar que los moldes antiguos cuando se trata de cazar fallos.
La sección (FIXME:xref:4) del programa muestra las conversiones de tipo implícitas
que normalmente se realizan de manera automática por el compilador. Son
automáticas y no requieren molde, pero el utilizar static_cast acentúa dicha acción
en caso de que se quiera reflejar claramente qué está ocurriendo, para poder
localizarlo después.
const_cast
Si quiere convertir de un const a un no-const o de un volatile a un no-volatile,
se utiliza const_cast. Es la única conversión permitida con const_cast;
si está involucrada alguna conversión adicional se debe hacer utilizando una
expresión separada o se obtendrá un error en tiempo de compilación.
//: C03:const_cast.cpp
int main() {
const int i = 0;
int* j = (int*)&i; // Deprecated form
j = const_cast(&i); // Preferred
// Can’t do simultaneous additional casting:
//! long* l = const_cast(&i); // Error
volatile int k = 0;
int* u = const_cast(&k);
106
✐
✐
✐
✐