C++

 

Tipos

Los diferentes valores (enteros, reales, caracteres, vectores, listas, diccionarios, etc.) que puede manejar un lenguaje se agrupan en tipos.

Un tipo se configura a partir de:

• un conjunto de valores

  Por ejemplo, un conjunto formado por enteros {…,-3,-2,-1,0,1,2,3,…}

• las operaciones permitidas para esos valores

  Por ejemplo, para los enteros disponemos de la suma (+), resta (-), división (/), multiplicación (*) y resto de la división entera (%)

• una aplicación que asocia a cada valor del tipo una representación binaria

  Por ejemplo, la representación binaria del valor -2 con tipo int en C/C++ es una agrupación de 32 bits:

  11111111111111111111111111111110

Usaremos habitualmente en el curso los siguientes tipos:

• bool para representar valores booleanos, es decir, cierto o falso.

• int para representar valores enteros.

• double para valores reales.

• char para caracteres.

• string para cadenas de caracteres.

• vector<tipo> para colecciones de datos del mismo tipo.

Clasificaciones

Los comités de estandarización de cada lenguaje o diferentes autores tienen (y varían en el tiempo) su propia terminología acerca de conceptos tales como tipo primitivo, tipo nativo, tipo básico, tipo fundamental, tipo compuesto, tipo escalar, etc. por lo que la bibliografía es confusa y contradictoria.

Una forma no bizantina de clasificarlos podría ser:

• Tipos nativos, proporcionados por el lenguaje, que pueden ser simples o compuestos.

  Por ejemplo, bool, char, int, float o double en C++

• Tipos definidos por el programador o suministrados por una biblioteca estándar.

  Por ejemplo, string o vector de la biblioteca estándar de C++

  Bloques de memoria

  La memoria del ordenador es el almacén de los diferentes valores que se generan al ejecutar un programa.

  La memoria se organiza como un conjunto de celdas, típicamente de tamaño 1 byte, cada una de ellas con una dirección asociada.

  La dirección en memoria

  La dirección permite acceder a la ubicación de cada celda y es un valor en si mismo y, por tanto, también puede almacenarse en otras celdas de la memoria.

  Así, en lenguajes como C/C++ existe el tipo puntero (pointer) cuyos valores asociados son direcciones.

   

  Disposición de las celdas

  El bloque de memoria necesario para almacenar un valor asociado a un tipo necesitará de una determinada cantidad de celdas y una determinada disposición de éstas.

  Por ejemplo, un char en C/C++ ocupa 1 byte y un double ocupa 8 bytes. Sin embargo, el equivalente al double en Python, el tipo float ocupa ¡24 bytes! El motivo es que Python no sólo almacena la representación binaria intrínseca del número, sino otra información relevante dadas las características de este lenguaje. De esos 24 bytes, 8 bytes contendrán los mismos bits que su equivalente en C/C++.

  En C++, el bloque de memoria asociado a los tipos de datos nativos está formado por celdas contiguas.

  Para otros tipos de datos y lenguajes, las celdas que conforman un bloque de memoria no tienen por qué ser contiguas. Pueden estar distribuidas en diferentes ubicaciones de la memoria.

  Por ejemplo, el tipo de dato de C++ vector<tipo>, utilizado para almacenar colecciones de valores de un mismo tipo, tiene sus atributos en posiciones no contiguas.

  Incluso el tamaño del bloque de memoria asociado a un tipo puede variar.

  El tipo int en Python tienen un número variable de celdas, aumentando conforme lo hace el valor absoluto representado. 

   

   

  Tipos nativos en C++

  En C++ hay una clara distinción entre los tipos de datos nativos o fundamentales (int, double, char, etc.) y otros tipos más sofisticados.

  Un bloque de memoria asociado a un tipo fundamental en C++ se caracteriza por:

  1. El número de celdas (bytes) que lo componen es fijo.

  2. Las celdas son contiguas.

  3. Hay un único valor representado, no hay información accesoria ni metadatos.

  A este tipo de datos se los conoce como datos POD (Plain Old Data), tipos simples, lisos, cuya representación interna binaria se limita a codificar el valor.

  C++ permite crear por parte del usuario nuevos tipos POD como agregación de otros tipos POD.

  En este caso, varía el punto 3 en el sentido de que ahora el tipo agregado representa varios valores POD.

Constantes literales

Permiten almacenar en el programa un valor que permanecerá constante a lo largo de la ejecución del programa.

Las constantes literales se almacenan al ejecutarse el programa en algún lugar de la memoria que no es accesible, del que desconocemos su posición.

Se caracterizan por:

• Su valor

• Su tipo: entero, carácter, punto flotante, lógicos, cadena de caracteres, etc.

Internamente se almacenarán con la representación del tipo al que pertenezcan.

Estas son algunas de las constantes literales más utilizadas:

Constantes lógicas

true, false

Constantes de tipo entero

Base decimal (10)

123, -23745

Base hexadecimal (16)

Comienzan con 0x: 0x1fa

Base octal (8)

Comienzan con 0: 0125

Constantes reales

Punto fijo

14.487, -.234

Exponencial

12.5e8, 1.2e-15

Constantes de tipo carácter

Rodeadas de comillas simples. Su valor se corresponde con su código ASCII.

'A', '\n'

Constantes de tipo cadena de caracteres

Se representan entre comillas. Son finalizadas automáticamente por el compilador en '\0'

"Hola mundo\n"

Expresiones y sentencias

Las expresiones permiten combinar datos y operadores para calcular otros datos, es decir, obtener un resultado.

Además, pueden contener palabras clave del lenguaje y signos de puntuación.

Un operador es un símbolo que determina la operación a realizar sobre los operandos (datos) a los que afecta.

Una sentencia es un conjunto de expresiones que permiten ejecutar una determinada acción.

En C++, las sentencias simples se caracterizan por terminar con el signo de puntuación ;.

(x + 3)*2          // expresión
a > b && c < d     // expresión
int x;             // sentencia
y = (x + 3)*2;     // sentencia

Variables

En los lenguajes de programación bajo el paradigma imperativo una variable permite asociar (enlazar, ligar) (bind) un identificador al bloque de memoria que almacena un valor.

Este bloque de memoria, a través de la variable, se podrá modificar y/o inspeccionar.

Advertencia

Este concepto de variable es diferente al de las variables matemáticas, a las que se las presupone un valor fijo y desconocido.

Declaraciones y definiciones

Una declaración es una sentencia que introduce el nombre o identificador de una variable en un programa. De esta forma, el compilador conocerá respecto al identificador:

• su tipo de dato

• los operadores permitidos con ese valor

Una definición complementa a una declaración estableciendo respecto a la entidad declarada:

• cuándo se crea

• dónde se crea, es decir, su posición en memoria

int x = 10; // Creamos un bloque de memoria int con nombre x
            // y almacenamos 10
int y = x;  // Creamos un nuevo bloque de memoria int con
            // nombre y, y copiamos el contenido de x
x = 20;     // Modificamos el bloque de memoria de nombre x
            // con el valor 20

A efectos prácticos, en el ámbito de este curso, la declaración y definición de una variable tienen lugar al mismo tiempo. Por ello, lo habitual en la bibliografía es hablar en términos de declarar una variable. Veremos más adelante con las funciones que éstas se pueden declarar en una parte del programa y definir en otra.

Tipado estático

C++ usa tipado estático, que caracteriza a aquellos lenguajes en los que el tipo asociado a una variable debe fijarse antes de uso en las diferentes partes del programa.

El tipado estático permite comprobar en tiempo de compilación la correcta asignación de cada variable a un determinado tipo y, en su caso, emitir los avisos y errores pertinentes.

En lenguajes como C/C++, en el ámbito (scope) en el que está definida la variable, el nombre de la variable identifica permanentemente al bloque de memoria.

Nota

Variables en Python

Como contraposición a ese enlace permanente, en lenguajes como Python una variable es una referencia temporal a un determinado bloque de memoria.

El identificador de la variable puede ligarse a diferentes bloques de memoria a lo largo de un programa.

x = 10     # Creamos un bloque de memoria int con valor 10.
           # Se asocia la variable x a ese bloque de memoria
y = x      # Se asocia la variable y al mismo bloque de
           # memoria al que apunta x. ¡No hay copia!
x = 'Hola' # Creamos un nuevo bloque de memoria str, cadena de caracteres.
           # Se asocia la variable x a ese bloque de memoria

Identificadores

Los identificadores nos permiten usar fácilmente los datos que están almacenados en memoria, despreocupándonos de su posición en memoria, su dirección.

Con objeto de aportar legibilidad a los programas, debemos usar identificadores autoexplicativos, informando implícitamente del cometido de la variable en el programa.

Por ejemplo, queremos representar una magnitud física correspondiente a una velocidad. ¿Qué identificador utilizar? Veamos 4 opciones:

double velocidad;     // PERFECTO
double vel;           // OK
double v;             // POCO EXPLICATIVO
double p;             // NADA EXPLICATIVO

Palabras reservadas

Tienen un significado especial para el compilador. Por ello, no pueden ser utilizadas como identificadores por el programador. Forman parte del vocabulario básico del lenguaje.

Estas son algunas de las más habituales:

Palabras reservadas heredadas del lenguaje C

auto const double float int short struct unsigned break continue else for long signed switch void case default enum goto register sizeof typedef volatile char do extern if return static union while

Palabras incorporadas al lenguaje C++

asm dynamic_cast namespace reinterpret_cast try bool explicit new static_cast typeid catch false operator template typename class friend private this using const_cast inline public throw virtual delete mutable protected true wchar_t

Normas

Un identificador no puede tener cualquier nombre. Las normas son las siguientes:

1. Debe empezar por una letra o carácter de subrayado.

   natural _var2 alumno_eii x1

   A pesar de estar permitido, es recomendable no usar el subrayado al inicio, pues es utilizado por los desarrolladores de bibliotecas y compiladores y, eventualmente, podemos generar una colisión.

2. Las mayúsculas son caracteres distintos que las minúsculas.

   interes e Interes son variables distintas.

3. No pueden utilizarse las palabras reservadas del lenguaje, como double, false, etc.

4. No deben llevar comas, puntos, acentos, espacios en blanco, la letra ñ, etc.

   tamaño var 1 interés dia.24 no son válidos.

Ámbito de las variables

El ámbito o alcance en un programa de una variable es la parte del programa donde la variable es accesible.

Básicamente podemos dividir a las variables en función del ámbito como locales o globales.

Variables globales

Las variables globales son accesibles por todas las funciones desde su declaración hasta el final del fichero.

El uso de variables globales no es aconsejable a pesar de que parezca útil y cómodo:

• Disminuye la legibilidad

• Su uso puede producir efectos colaterales, al producirse alteraciones no previstas de su valor en una parte del programa que afectan a su uso en otra zona.

• Dificultan la modularidad del código.

Las variables y/o funciones globales se justifican cuando se necesitan en casi todas las funciones del programa.

Las variables std::cin y std::cout, que estudiaremos en breve, son globales).

Ejemplo de uso de variables globales

Las funciones de este programa, main() y mi_funcion(), son interdependientes. Esto es, en general, ¡una situación no deseable!

#include <iostream>
double z = 1.;        // Se declara z como global.
void mi_funcion();  // Estudiaremos las funciones mas adelante
int main()
{
   std::cout << z << std::endl;
   z = z + 1.;
   std::cout << z << std::endl;
   mi_funcion();     // Funcion modifica el valor de z
   std::cout << z << std::endl;
}
void mi_funcion() //Estudiaremos las funciones más adelante
{
   z = z*z;
}

Edita, compila y ejecuta el código

Advertencia

¡En este curso no se permitirá el uso de variables globales! Veremos más adelante una solución de compromiso, los espacios de nombres (namespaces).

Variables locales

Las variables locales son accesibles desde su declaración hasta el final del bloque de código del fichero en el que han sido declaradas.

Un bloque de código viene determinado por una pareja de llaves { }.

Si el bloque donde se ha declarado la variable local contiene a su vez otros bloques, también es accesible dentro de ellos.

En caso de que una variable aparezca declarada en varios niveles de anidamiento dentro de un bloque, prevalece la declaración del bloque más interno.

#include <iostream>
using namespace std;

int main()
{
   double z = 0.;
   cout << z << endl;
   {
      z = z + 1.;
      {
         int z = 2;    //Declaración local con el mismo nombre
         cout << z << endl;
      }
      {
         cout << z << endl;
      }
   }
}

Edita, compila y ejecuta el código

Atención

Dada su escasa legibilidad, las declaraciones anidadas de la misma variable, como las del ejemplo, son situaciones que nunca deberían ocurrir en un programa bien diseñado.

Las variables locales se destruyen, dejan de ser accesibles, cuando la ejecución del programa abandona el bloque donde han sido declaradas.

Nota

El término destruir hace referencia a que el bloque de memoria asociado a la variable pasa a estar disponible para albergar otra variable que se defina posteriormente en el programa, que eventualmente sobrescribirá los bits antiguos.

En la siguiente figura se visualizan los diferentes ámbitos del ejemplo anterior.

Operadores aritméticos

Permiten realizar operaciones aritméticas sobre sus operandos.

Operadores aritméticos

Operador	Descripción
+	suma
-	resta
*	producto
/	división
%	resto de la división entera

Atención

El operador aritmético % sólo es aplicable a datos enteros. Por ejemplo: 23%5 es 3. Equivale a 23-(23/5)*5

Cada operación realizada con los operandos genera un resultado que se almacenará en alguna posición de memoria.

El tipo del valor generado y, por tanto, su representación interna, dependerá de los tipos de los operandos.

Reglas de precedencia

Cuando se combinan diferentes operadores, el valor determinado por una expresión se calcula siguiendo un orden de evaluación en función de unas reglas de precedencia.

La siguiente expresión ilustra la necesidad de disponer de reglas de precedencia.

3 + 2 * 5

• Habrá quien realice en primer lugar la operación 3 + 2 para, a continuación, multiplicar el resultado por 5. El resultado obtenido para la expresión sería 25.

• Por el contrario, otros calcularán en primer lugar el producto 2 * 5 para, finalmente, sumar al resultado 3. El resultado obtenido será en este caso 13.

En C++ y otros muchos lenguajes, se sigue el orden normal establecido en la aritmética, realizándose las operaciones de izquierda a derecha siguiendo el siguiente orden:

1. Se evalúan las expresiones entre paréntesis

2. Potencias (C++ no dispone de un operador nativo, pero otros lenguajes como Python sí)

3. Multiplicación, división y resto de la división entera

4. Suma y resta

Precedencia de los operadores utilizados hasta el momento

Precedencia	Operador	Descripción	Asociatividad
1	::	Resolución de ámbito	Izquierda a derecha
2	(expresion)	Expresión entre paréntesis	Izquierda a derecha
5	* / %	Multiplicación, división y división entera	Izquierda a derecha
6	+ -	Suma y resta	Izquierda a derecha
7	<< >>	Extracción e inserción	Izquierda a derecha
16	=	Asignación	Derecha a izquierda

Véase la tabla de precedencia completa de C++.

La columna de la izquierda de la tabla indica el rango u orden de precedencia. Nótese que, a excepción del operador ::, del que ya hemos hablado con anterioridad, las expresiones entre paréntesis están en el nivel 2.

Por ello, el uso de paréntesis es una excelente estrategia para determinar de forma clara qué operaciones se desean realizar en primer lugar.

Veámoslo en el siguiente ejemplo:

// Operaciones con constantes literales enteras
(3 + 2)*5         // 1º) (3 + 2) 2º) 5*5: Resultado 25
(3 + 2)*12/5      // 1º) (3 + 2), 2º) 5*12, 3º) 60/5: Resultado 12
(3 + 2)*(12/5)    // 1º) (3 + 2), 2º) (12/5) 3º) 5*2: Resultado 10

Edita, compila y ejecuta el código

Se pueden anidar paréntesis tanto como se necesite.

a*(((b + 2) + 3) + z)

Operadores de asignación

El operador = es un operador sobrecargado. Un operador se llama sobrecargado cuando dependiendo del contexto acomete distintas operaciones. En el contexto de la asignación, el operador = se utiliza para modificar el valor de las variables, es decir, altera el bloque de memoria asociado a una variable.

Analizando la tabla de precedencia completa observa que es uno los operadores con menor precedencia. Por tanto, en una sentencia simple típica, será la última operación realizada.

Supongamos que y es una variable de tipo double ligada a un bloque de memoria con valor 2.0.

y = y + 1.5;

Tras obtener el resultado de la expresión y + 1.5, inmediatamente después de la asignación y tendrá un valor 3.5.

Advertencia

El operador de asignación no es equivalente a la igualdad matemática: una sentencia como la anterior, y = y + 1.5;, no tiene sentido en matemáticas.

Valores por la izquierda y valores por la derecha

Una expresión genera un valor por la izquierda (Lvalue) cuando el bloque de memoria donde se almacena el resultado obtenido es accesible desde el programa y, por tanto, persiste y podemos modificarlo posteriormente.

El nombre se debe a que estas expresiones normalmente se utilizan en el lado izquierdo del operador de asignación =. Típicamente son nombres de variables.

Por el contrario, una expresión genera un valor por la derecha (Rvalue) cuando el bloque de memoria donde será almacenado no tiene una posición específica: probablemente se almacenará temporalmente en algún registro de la CPU durante la ejecución del programa.

Una expresión Rvalue no puede aparecer nunca en el lado izquierdo del operador de asignación =.

y = 5;
x = (y + 3) + 8;
z = x + 3;

En la segunda sentencia del anterior fragmento de código, x es una expresión Lvalue, pero (y + 3) es una expresión Rvalue. En algún momento de la ejecución de la sentencia el resultado de (y + 3), que es 8, se almacenará en algún registro de la CPU. Pero en ningún momento podemos acceder a esa posición de memoria: el resultado 8 no persiste.

Por el contrario, el valor de x tras la ejecución de la sentencia, 16, persiste, es accesible. Por ello, podemos reusarlo en la siguiente línea.

Por ello, en general, a la izquierda de la asignación siempre aparece una variable. A la derecha cualquier expresión válida.

y = (2 + 3.5)/3.1 + a;  // OK
vel = x;                // OK
masa = 5.6;             // OK
x + y = u + w;          // ERROR
2 = z;                  // ERROR

El operador de asignación es de los pocos operadores que se evalúan de derecha a izquierda.

Por ello, sentencias como la siguiente son válidas:

x = a = 2;  // Primero se asigna a = 2, luego x = a

Operadores de asignación compuestos

En C, C++, Python, Java, etc. son muy utilizados los operadores de asignación compuestos.

La idea es que si tenemos una sentencia del tipo a = a OP b;, donde OP es típicamente uno de los operadores aritméticos, podemos abreviadamente utilizar la alternativa a OP= b;.

a += b;    // equivale :  a = a + b
a -= b;    // equivale :  a = a - b
a *= b;    // equivale :  a = a * b
a /= b;    // equivale :  a = a / b
a %= b;    // equivale :  a = a % b

Debe tenerse en cuenta que estos operadores no solo permiten escribir una sentencia de una forma más abreviada. Internamente, el compilador generará instrucciones más eficientes, ya que le estamos informando de que uno de los operandos será el destino final de la expresión evaluada.

Advertencia

Nótese que OP= debe escribirse con los dos símbolos seguidos, sin espacios en blanco.

a + = b;    // ¡ERROR!

Operador de inicialización

El símbolo = también se usa como operador para inicializar las variables.

int num = 5;

Como hemos comentado, el operador = es un operador sobrecargado y es interesante conocer la diferencia cuando se usa para asignar de cuando se utiliza para inicializar. Aunque el resultado final almacenado en la variable sea el mismo, la CPU necesitará hacer operaciones distintas para cada uno de los operadores.

La sentencia

int num = 5; // Inicialización por copia

es distinta que:

int num; // Variable sin inicializar
num = 5; // Asignación del valor 5 a num

Es cierto que para el caso de los tipos de datos básicos (int, double, etc.), ambas secuencias de sentencias producen el mismo resultado, pero para tipos de datos más complejos esto no es así.

Una primera gran diferencia: se inicializa una única vez; se asigna cuantas veces sea necesario.

Diferencia entre inicializar y asignar

Para entender mejor la diferencia veamos el siguiente símil.

Supongamos un problema en el cual tenemos un contenedor con cubos de colores blanco y negro (cada cubo representaría un bit: 0 o 1).

Pedimos a una persona (CPU) que construya una torre (el tipo de dato) con cierto número de cubos sobre una mesa (la memoria).

Las únicas operaciones permitidas son las de una pila:

• apilar: coger un cubo y depositarlo sobre la torre

• desapilar: coger el cubo superior de la torre y dejarlo en el contenedor

Arranca el programa. La mesa está vacía. Tenemos 3 sentencias.

• 1ª sentencia: inicialización: formar una torre con 3 cubos blancos.

  El proceso consiste en buscar un cubo blanco, cogerlo, dejarlo en cierta posición sobre la mesa (la dirección de memoria) e ir formando la torre.

• 2ª sentencia: asignación: modificar la torre de tal forma que el cubo intermedio sea negro.

  El proceso en este caso consiste en quitar sucesivamente dos cubos blancos, coger un cubo negro del contenedor y dejarlo sobre la torre y coger un cubo blanco del contenedor y dejarlo sobre la torre.

• 3ª sentencia: inicialización: formar una nueva torre con 2 cubos blancos y uno negro, siendo este último el intermedio.

Las 2 torres actualmente sobre la mesa (memoria) son iguales, pero la CPU ha realizado operaciones diferentes para crearlas debido a que la primera se formó por asignación (ya existía una torre ahí) y la segunda por inicialización.

Inicialización uniforme

Además de la sintaxis de incialización que hemos visto, inicialización por copia, desde el estándar C++11, se dispone de una nueva sintaxis, conocida como inicialización uniforme.

int num{5};
int num{}; // Inicializa a 0

Una ventaja de esta forma de inicialización es que deduce el tipo de las constantes literales y el compilador nos avisa de un posible error.

int x = 3.3;   // Posible aviso: trunca la parte decimal
int num{3.3};  // Error

Edita, compila y ejecuta el código

En el caso de la inicialización por copia, y dependiendo del compilador, tendremos un aviso (warning).

Aunque la sintaxis de inicialización uniforme es la recomendada, la inicialización por copia está presente en millones y millones de líneas de código por lo que la usaremos también habitualmente en el curso cuando inicialicemos variables de tipos de datos básicos.

Advertencia

Existe otra sintaxis de inicialización, llamada directa, cuyo uso está desaconsejado: int num(5);.

Sentencias de definición, inicialización y asignación

Las sentencias de definición introducen nuevas variables en el ámbito en el que son declaradas, es decir, el conjunto de sentencias situadas entre llaves { }.

{
   // código
   int x;
   // código
}

Nótese en el ejemplo que, tras la definición, el valor de la variable x es indefinido.

Por ello, siempre que sea posible, es conveniente definir e inicializar en el mismo paso.

{
   // código
   int x = 0;
   int y{};
   double z{};
   // código
}

Nota

Recordad que con la inicialización uniforme la variable y se inicializa automáticamente 0 y la z a 0.0.

Las sentencias de asignación evalúan la expresión situada a la derecha del operador = y asignan el resultado a la variable situada a la izquierda.

x = 2*y;

Nótese en todos estos tipos de sentencias simples la finalización con el signo de puntuación ;.

¿Dónde realizar las sentencias de definición e inicialización?

C++ usa tipado estático lo que, entre otras cosas, implica que una variable tiene que estar declarada antes de poder utilizarla en una expresión.

Para el caso de variables correspondientes a tipos nativos, no existe una restricción respecto al lugar en un programa donde realizar las sentencias de definición e inicialización de variables.

Sin embargo, por legibilidad y eficiencia lo lógico es hacerlo lo más cerca posible de la primera expresión en la que vayan a ser utilizadas las variables.

• Damos información contextual a las líneas siguientes, como por ejemplo, el tipo de dato involucrado en una operación.

• Podemos estar seguros que esa variable no afecta al programa aguas arriba.

• Es más difícil que olvidemos inicializarla, pues la vamos a usar de forma inmediata.

El siguiente ejemplo ilustra la idea anterior. No obstante, al compilar genera un error. ¡Corrígelo!

#include <iostream>
using namespace std;
int main()
{
   // Tropecientas líneas más abajo
   cout << "Dame un número: ";
   int x;
   cin >> x;

   // Tropecientas líneas más abajo
   cout << "Dame otro número: ";
   cin >> y;
   int y;
   cout << "La suma es: " << x + y << endl;
}

Edita, compila y ejecuta el código

Conversión entre tipos de datos

El hecho de que C++ sea un lenguaje estáticamente tipado, significa que los tipos asignados a las variables se comprueban en tiempo de compilación.

Así, el compilador verifica que las operaciones que el programador ha escrito en el código fuente están soportadas por el lenguaje. Si existe alguna incompatibilidad, el compilador avisará con un mensaje de error.

Como acabamos de ver, difícilmente el compilador podría realizar esta tarea si previamente no hemos declarado los tipos de las variables antes de ser utilizadas.

No obstante, los lenguajes estáticamente tipados sí que permiten mezclar tipos de dato en las expresiones a pesar de que sus representaciones internas sean diferentes.

Para trabajar de forma cómoda con estas situaciones, los lenguajes permiten que el programador adopte dos tipos de decisión:

• Conversión implícita: El compilador se encarga de forma automática de adaptar las representaciones para poder efectuar los cálculos de forma correcta.

• Conversión explícita: El programador escribe explícitamente en el código fuente cómo quiere que se haga la conversión entre las representaciones.

Conversión implícita

Inicialización directa y asignaciones

C++ evalúa la expresión a la derecha del operador = y el resultado se convierte implícitamente al tipo de dato situado a su izquierda.

• La conversión de una expresión con un valor de tipo real a una variable de tipo entero se trunca al entero resultante de eliminar la parte fraccionaria.

  int r = 48.1;  // r se almacenará como entero con valor 48
  int s = -28.1; // s se almacenará como entero con valor -28
  

• La conversión de una expresión con un valor de tipo entero a una variable de tipo real se realizará según la norma IEEE 754. Puede conllevar la pérdida de precisión en números grandes para los float, no así para los double, que tienen suficientes bits (una razón más para usar siempre double).

  float x = 19999999;  // x se almacenara como real 20000000
  double y = 19999999; // y se almacenara como real 19999999
  

• Una expresión no boolena solo se asigna a false si el valor es 0. En caso contrario, el resultado de la asignación es true.

  bool b = 48.1; // b es cierto
  bool b{1};     // OK: inicialización uniforme sólo valores 0 (false) y 1 (true)
  bool b{48.1};  // ERROR: inicialización uniforme
  

Edita, compila y ejecuta el código

Operaciones en expresiones

Cuando aparece una expresión con distintos tipos de datos mezclados, C++ promueve todos los tipos a un único tipo, el que tiene más jerarquía de entre los presentes. De esta forma, la operación (aritmética o lógica) se realiza según la representación del tipo de mayor jerarquía.

Para los tipos de datos que vamos a manejar en la asignatura, la jerarquía de menor a mayor en C++ es:

bool < int

char < int < float < double

Véase el siguiente ejemplo.

int x = 1;
double y = 19999998;
// x + y es una expresión RValue que se evalúa como double.
// Al ejecutarse el programa, su valor será 19999999.
float w = x + y;   // w se almacena con valor float  20000000
double z = x + y;  //z se almacena con valor double 19999999

Edita, compila y ejecuta el código

Conversión explícita

En ocasiones el programador necesita forzar la conversión.

Imaginemos un problema en el cual deseamos calcular la pendiente media de un puerto de montaña. Para la longitud del puerto y para la altitud se han elegido variables enteras que representan metros.

La fórmula será pendiente=altitud/longitud$���������=�������/��������$.

Un programa ejemplo podría ser el siguiente:

#include <iostream>
using namespace std;
int main()
{
   int longitud = 18342;
   int altitud = 1123; //Respecto a la base del puerto

   double pendiente = altitud/longitud;

   cout << "La pendiente es " << pendiente << endl;
}

Edita, compila y ejecuta el código

Quizás para muchos sea una sorpresa que el resultado para la pendiente sea 0, pero es totalmente lógico.

Las expresiones a la derecha de una asignación = se evalúan antes de realizarse la asignación, almacenándose en un registro interno. En el ejemplo, la operación altitud/longitud es una expresión que involucra 2 variables tipo int y puesto que el resultado real es 0.xxxx se trunca a 0. Y es este valor 0 el que se asigna a la variable pendiente.

Un programa para obtener el valor correcto sustituiría la línea de cálculo de la pendiente por la siguiente:

double pendiente = static_cast<double>(altitud)/longitud;
// double pendiente = double(altitud)/longitud;  //Estilo C++ antiguo
// double pendiente = (double)altitud/longitud;  //Estilo C

Edita, compila y ejecuta el código

La conversión forzada de tipos static_cast<tipo_de_dato>(expresion) convierte la representación interna de expresion a la representación marcada por tipo_de_dato.

En nuestro ejemplo, forzamos a que la representación interna de la variable altitud sea double. De esta forma, la expresión altitud/longitud se convertirá implícitamente a double y obtendremos el resultado correcto.

Existen otras alternativas para realizar conversiones forzadas tales como:

• double pendiente=double(altitud)/longitud;

• double pendiente=(double)altitud/longitud;

Aunque para el ejemplo que nos ocupa todas las opciones son válidas y compilarán perfectamente, se recomienda usar static_cast.

La conversión forzada:

double pendiente = static_cast<double>(altitud/longitud);

no funciona correctamente. ¿Por qué?

Por otro lado, en la medida de lo posible, debemos evitar el uso de las conversiones forzadas. En el ejemplo hubiese bastado con declarar:

double longitud = 18342;
double altitud = 1123;

Peligro

Las conversiones descontroladas conllevan graves riesgos. Un ejemplo clásico es el ocurrido con el cohete Ariane, que se produjo por una conversión desde un número en coma flotante de 64 bits (que era mayor de 32768) a un número entero de 16 bits.