Disponible la nueva versión "donationware" 7.3 de OrganiZATOR
Descubre un nuevo concepto en el manejo de la información.
La mejor ayuda para sobrevivir en la moderna jungla de datos la tienes aquí.

Curso C++

[Home]  [Inicio]  [Índice]


4.9.9a  El operador const_cast

§1  Sinopsis:

La palabra clave const_cast identifica un operador de uso muy específico: sirve para poner o quitar los atributos const o volatile de un objeto. La sintaxis general es:

const_cast< T > (arg)

En la expresión anterior, T y arg deben ser del mismo tipo, excepto en los atributos const ( 3.2.1c ) y volatile ( 4.1.9). T es el tipo al que se quiere convertir, arg es el tipo de partida (ver ejemplo). El modelado es resuelto en tiempo de compilación, y el resultado es del tipo T.  Una sola expresión const_cast puede poner o quitar el atributo const o volatile a cualquier número de objetos.

Ejemplo

const int x = 10;

int* iptr = &x;    // Error!!

Un intento de compilar las sentencias anteriores conduce a un error del compilador:

invalid conversion from `const int*' to `int*' 

La razón es que se está intentando asignar la dirección de un int-const a un puntero-a-int, cuando se necesitaría un puntero-a-int-const. Suponiendo que no queramos (o podamos) cambiar la definición de iptr, el problema de la asignación en la segunda línea puede resolverse mediante un "casting" adecuado:

const int x = 23; 
int* iptr = const_cast<int*> (&x);  // Ok!!

§2  cons_cast con punteros

El cambio de atributo puede utilizarse con punteros, de forma que un puntero a-tipoX-constante puede ser convertido en puntero a-tipoX y viceversa.  El cambio también puede realizarse con un puntero a-tipoX-volatile.

El puntero obtenido es idéntico al original en todos los demás aspectos. Si la conversión tiene éxito el puntero resultante señala al mismo objeto que el original. Ejemplo:

const int kte = 35;
int* ptr;
ptr = &kte;                      // Error!
ptr = (int*) &kte;               // modelado antiguo desaconsejado
ptr = const_cast<int*> (&kte);   // Ok:
volatile int x = 45;
ptr = &x;                        // Error!
ptr = const_cast<int*> (&x);     // Ok:


Así pues, este operador convierte un objeto (o referencia a objeto) const o volatile en un objeto (o referencia) no-const o no-volatile que es idéntico en lo demás al original.

Es importante advertir que el operador const_cast no cambia el tipo del operando, lo que significa que este operador no hace que una variable constante pueda volverse no-constante y ver alterado su valor después de aplicado el operador. Considere detenidamente el resultado obtenido en el siguiente ejemplo, e intente llegar a una explicación (recuerde lo señalado al respecto en 4.2.1e).

#include <iostream.h>

int main() {
  const int x = 35;             // constante iniciada a 35
  int* ptr;                     // puntero a entero
  ptr = const_cast<int*> (&x);  // Ok: (gracias al 'casting')
  cout << "Valor x = " << *ptr << endl;
  *ptr = 100;                   // Se asigna un valor a x ?!!
  cout << "Valor x = " << *ptr << endl;
  cout << "Valor x = " << x << endl;
  int z = 10 + x;               // Comprobación del valor de x
  cout << "x + 10 = " << z << endl;
}

Salida:

Valor x = 35
Valor x = 100
Valor x = 35
x + 10 = 45