Esta sección discutirá la conversión de tipos de las variables en el lenguaje de programación C++. La conversión de tipos se refiere a la conversión de un tipo de datos a otro en un programa. El encasillamiento se puede realizar de dos maneras: automáticamente por el compilador y manualmente por el programador o usuario. La conversión de tipos también se conoce como conversión de tipos.
Por ejemplo, supongamos que los datos proporcionados son de tipo entero y queremos convertirlos a tipo flotante. Por lo tanto, necesitamos convertir manualmente datos int al tipo flotante, y este tipo de conversión se llama conversión de tipos en C++.
int num = 5; float x; x = float(num); x = 5.0
2Dakota del Norteejemplo:
float num = 5.25; int x; x = int(num); Output: 5
La conversión de tipos se divide en dos tipos: conversión implícita o conversión de tipos implícita y conversión de tipos explícita o conversión de tipos explícita.
Conversión de tipos implícita o conversión de tipos implícita
- Se le conoce como fundición automática de tipos.
- Convirtió automáticamente de un tipo de datos a otro sin ninguna intervención externa, como programador o usuario. Significa que el compilador convierte automáticamente un tipo de datos en otro.
- Todos los tipos de datos se actualizan automáticamente al tipo más grande sin perder ninguna información.
- Sólo puede aplicarse en un programa si ambas variables son compatibles entre sí.
char - sort int -> int -> unsigned int -> long int -> float -> double -> long double, etc.
Nota: La conversión de tipos implícita se debe realizar desde tipos de datos más bajos a más altos. De lo contrario, afecta el tipo de datos fundamental, lo que puede perder precisión o datos, y el compilador podría mostrar una advertencia a este efecto.
Programa para utilizar la conversión de tipos implícita en C++
Creemos un ejemplo para demostrar la conversión de una variable a otra usando la conversión de tipos implícita en C++.
#include using namespace std; int main () { short x = 200; int y; y = x; cout << ' Implicit Type Casting ' << endl; cout << ' The value of x: ' << x << endl; cout << ' The value of y: ' << y << endl; int num = 20; char ch = 'a'; int res = 20 + 'a'; cout << ' Type casting char to int data type ('a' to 20): ' << res << endl; float val = num + 'A'; cout << ' Type casting from int data to float type: ' << val << endl; return 0; } Producción:
Implicit Type Casting The value of x: 200 The value of y: 200 Type casting char to int data type ('a' to 20): 117 Type casting from int data to float type: 85
En el programa anterior, declaramos una variable de tipo de datos corto x es 200 y una variable entera y. Después de eso, asignamos el valor de x a y, y luego el compilador convierte automáticamente el valor de datos cortos x a y, lo que devuelve y es 200.
En las siguientes expresiones, declaramos una variable de tipo int num es 20, y la variable de tipo carácter ch es 'a', lo que equivale a un valor entero de 97. Y luego, sumamos estas dos variables para realizar la conversión implícita, que devuelve el resultado de la expresión es 117.
De manera similar, en la tercera expresión, agregamos la variable entera num es 20 y la variable de carácter ch es 65, y luego asignamos el resultado a la variable flotante val. Por lo tanto, el compilador convierte automáticamente el resultado de la expresión al tipo flotante.
Conversión de tipo explícita o conversión de tipo explícita
- También se conoce como conversión de tipo manual en un programa.
- El programador o el usuario lo emite manualmente para cambiar de un tipo de datos a otro tipo en un programa. Significa que un usuario puede convertir fácilmente un dato en otro según los requisitos de un programa.
- No requiere comprobar la compatibilidad de las variables.
- En esta conversión, podemos actualizar o degradar el tipo de datos de una variable a otra en un programa.
- Utiliza el operador cast () para cambiar el tipo de una variable.
Sintaxis de la conversión de tipos explícita
(type) expression;
tipo: Representa los datos definidos por el usuario que convierten la expresión dada.
expresión: Representa el valor constante, variable o expresión cuyo tipo de datos se convierte.
Por ejemplo, tenemos un número de coma flotante que es 4,534 y para convertir un valor entero, la declaración es la siguiente:
int num; num = (int) 4.534; // cast into int data type cout << num;
Cuando se ejecutan las declaraciones anteriores, el valor de punto flotante se convertirá en un tipo de datos entero utilizando el operador cast (). Y el valor flotante se asigna a un número entero que trunca la parte decimal y muestra solo 4 como valor entero.
Programa para demostrar el uso de la conversión de tipos explícita en C++
Creemos un programa simple para convertir una variable de tipo en otro tipo usando la conversión de tipos explícita en el lenguaje de programación C++.
#include using namespace std; int main () { // declaration of the variables int a, b; float res; a = 21; b = 5; cout << ' Implicit Type Casting: ' << endl; cout << ' Result: ' << a / b << endl; // it loses some information cout << '
Explicit Type Casting: ' << endl; // use cast () operator to convert int data to float res = (float) 21 / 5; cout << ' The value of float variable (res): ' << res << endl; return 0; } Producción:
Implicit Type Casting: Result: 4 Explicit Type Casting: The value of float variable (res): 4.2
En el programa anterior, tomamos dos variables enteras, a y b, cuyos valores son 21 y 2. Y luego, dividimos a por b (21/2) que devuelve un valor de tipo 4 int.
En la segunda expresión, declaramos una variable de tipo flotante res que almacena los resultados de a y b sin perder ningún dato usando el operador de conversión en el método de conversión de tipo explícito.
Programa para convertir datos dobles en tipos int y float usando el operador de conversión
Consideremos un ejemplo para obtener el área del rectángulo convirtiendo datos dobles en tipos float e int en programación C++.
#include using namespace std; int main () { // declaration of the variables double l, b; int area; // convert double data type to int type cout << ' The length of the rectangle is: ' <> l; cout << ' The breadth of the rectangle is: ' <> b; area = (int) l * b; // cast into int type cout << ' The area of the rectangle is: ' << area << endl; float res; // convert double data type to float type cout << '
The length of the rectangle is: ' << l << endl; cout << ' The breadth of the rectangle is: ' << b << endl; res = (float) l * b; // cast into float type cout << ' The area of the rectangle is: ' << res; return 0; } Producción:
The length of the rectangle is: 57.3456 The breadth of the rectangle is: 12.9874 The area of the rectangle is: 740 The length of the rectangle is: 57.3456 The breadth of the rectangle is: 12.9874 The area of the rectangle is: 744.77
Algunos tipos diferentes de fundición tipográfica
En la conversión de tipos, hay un operador de conversión que obliga a convertir un tipo de datos en otro tipo de datos según las necesidades del programa. C++ tiene cuatro tipos diferentes de operador de conversión:
- transmisión estática
- transmisión_dinámica
- const_cast
- reinterpretar_cast
Reparto estático:
static_cast es una conversión simple en tiempo de compilación que convierte o convierte un tipo de datos en otro. Significa que no verifica el tipo de datos en tiempo de ejecución si la conversión realizada es válida o no. Por tanto, el programador o usuario tiene la responsabilidad de garantizar que la conversión sea segura y válida.
static_cast es lo suficientemente capaz como para realizar todas las conversiones realizadas por la conversión implícita. Y también realiza las conversiones entre punteros de clases relacionadas entre sí (upcast - > de clase derivada a base o downcast - > de clase base a derivada).
Sintaxis del reparto estático
static_cast (expression);
Programa para demostrar el uso del Static Cast
Creemos un ejemplo simple para usar la conversión estática de la conversión de tipos en la programación C++.
#include using namespace std; int main () { // declare a variable double l; l = 2.5 * 3.5 * 4.5; int tot; cout << ' Before using the static cast:' << endl; cout << ' The value of l = ' << l << endl; // use the static_cast to convert the data type tot = static_cast (l); cout << ' After using the static cast: ' << endl; cout << ' The value of tot = ' << tot << endl; return 0; } Producción:
Before using the static cast: The value of l = 39.375 After using the static cast: The value of tot = 39
Reparto dinámico
Dynamic_cast es un operador de conversión en tiempo de ejecución que se utiliza para realizar la conversión de una variable de tipo a otra solo en referencias y punteros de clase. Significa que verifica la conversión válida de las variables en el tiempo de ejecución y, si la conversión falla, devuelve un valor NULL. La conversión dinámica se basa en el mecanismo RTTI (Identificación de tipo de tiempo de ejecución).
Programa para demostrar el uso de Dynamic Cast en C++
Creemos un programa simple para realizar Dynamic_cast en el lenguaje de programación C++.
#include using namespace std; class parent { public: virtual void print() { } }; class derived: public parent { }; int main () { // create an object ptr parent *ptr = new derived; // use the dynamic cast to convert class data derived* d = dynamic_cast (ptr); // check whether the dynamic cast is performed or not if ( d != NULL) { cout << ' Dynamic casting is done successfully'; } else { cout << ' Dynamic casting is not done successfully'; } } Producción:
Dynamic casting is done successfully.
Reinterpretar el tipo de reparto
La conversión de tipo reinterpret_cast se utiliza para convertir un puntero a cualquier otro tipo de puntero, ya sea que el puntero dado pertenezca o no. Significa que no comprueba si el puntero o los datos a los que apunta el puntero son iguales o no. Y también arroja un puntero a un tipo de número entero o viceversa.
Sintaxis del tipo reinterpret_cast
reinterpret_cast expression;
Programa para utilizar Reinterpret Cast en C++
Escribamos un programa para demostrar la conversión de un puntero utilizando la reinterpretación en lenguaje C++.
#include using namespace std; int main () { // declaration of the pointer variables int *pt = new int (65); // use reinterpre_cast operator to type cast the pointer variables char *ch = reinterpret_cast (pt); cout << ' The value of pt: ' << pt << endl; cout << ' The value of ch: ' << ch << endl; // get value of the defined variable using pointer cout << ' The value of *ptr: ' << *pt << endl; cout << ' The value of *ch: ' << *ch << endl; return 0; } Producción:
The value of pt: 0x5cfed0 The value of ch: A The value of *ptr: 65 The value of *ch: A
reparto constante
const_cast se utiliza para cambiar o manipular el comportamiento constante del puntero de origen. Significa que podemos realizar la constante de dos maneras: estableciendo un puntero constante en un puntero no constante o eliminando o eliminando la constante de un puntero constante.
Sintaxis del tipo Const Cast
const_cast exp;
Programa para utilizar Const Cast en C++
java intenta atrapar
Escribamos un programa para convertir un puntero fuente a un puntero no fundido usando const_cast en C++.
#include using namespace std; // define a function int disp(int *pt) { return (*pt * 10); } int main () { // declare a const variable const int num = 50; const int *pt = # // get the address of num // use const_cast to chnage the constness of the source pointer int *ptr = const_cast (pt); cout << ' The value of ptr cast: ' << disp(ptr); return 0; } Producción:
The value of ptr cast: 500