Variables y tipos de datos en C++: Guía experta sobre int, double, char, string, bool

Variables en C++

En C++, una variable es una ubicación de almacenamiento con nombre que permite al programador guardar y manipular datos. Cada variable tiene un tipo explícito que determina su tamaño en memoria, el rango de valores permitidos y las operaciones que se pueden realizar sobre ella.

Este tutorial cubre:

• Variables en C++
• Tipos básicos de variables
• Reglas de declaración
• Jerarquía de tipos de datos
• Identificadores y convenciones de nomenclatura
• Calificador const
• Reglas de ámbito
• Conversión de tipos implícita y explícita
• Variables register
• Comentarios y secuencias de escape

Tipos básicos de variables en C++

int – Números enteros sin parte fraccionaria ni exponencial (ej. 120, -90).

double – Números de punto flotante de doble precisión (ej. 11.22, 2.345).

char – Caracteres literales individuales entre comillas simples (ej. 'a', 'm', 'F', 'P', '}').

float – Valores de punto flotante de precisión simple (ej. 1.3, 2.6).

string – Secuencia de caracteres entre comillas dobles (ej. "¿Cómo estás?").

bool – Almacena true o false.

Reglas para declarar variables en C++

• Los nombres pueden contener letras, dígitos y guiones bajos.
• No pueden comenzar con un dígito.
• La convención favorece minúsculas; las mayúsculas iniciales suelen denotar constantes.
• No deben coincidir con palabras reservadas del lenguaje (ej. int).
• Comenzar con guion bajo está permitido pero desaconsejado por reglas de identificadores reservados.

Tipos de datos de variables en C++

C++ ofrece un amplio conjunto de tipos primitivos. El tipo void no tiene valor y se usa típicamente como tipo de retorno de funciones que no devuelven nada.

Los tipos aritméticos se dividen en dos categorías:

1. Tipos de punto flotante: float (≈32 bits), double (≈64 bits) y long double (≈96/128 bits según implementación).
2. Tipos enteros: enteros, caracteres y bool. Los tipos enteros pueden ser con signo o sin signo.

Los tipos con signo representan valores negativos, cero y positivos. Por ejemplo, un char con signo de 8 bits va de –127 a 127.

Los tipos sin signo solo almacenan valores no negativos. Un char sin signo de 8 bits va de 0 a 255.

Nombres de variables o identificadores

Los identificadores pueden contener letras, dígitos y guiones bajos. La longitud es ilimitada y distinguen mayúsculas/minúsculas:

int guru99, gurU99, GuRu99, GURU99;

Las palabras reservadas no pueden reutilizarse como identificadores. Adoptar convenciones claras mejora la legibilidad: use minúsculas para variables, camelCase o snake_case para nombres compuestos, y capitalice nombres de clases.

Ejemplos de declaración y definición

int a = 5;
int b;
char c = 'A';
int a, b;
a = b = 1000;
int a(5);
int b{5};

Calificador const en C++

Use const cuando un valor no deba cambiar tras la inicialización:

const int bufSize = 512; // tamaño de búfer de entrada

Una variable const debe inicializarse; de lo contrario, el compilador emite un error.

const int i = get_size(); // OK: inicialización en tiempo de ejecución
const int j = 42;         // OK: inicialización en tiempo de compilación
const int k;              // error: const sin inicializar
const int i = 42;
const int ci = i;         // OK: copia de i

Ámbito de las variables en C++

El ámbito define dónde es visible un nombre. Las variables son accesibles desde su punto de declaración hasta el final del bloque que las contiene.

#include <iostream>
int main() {
    int sum = 0;
    for (int val = 1; val <= 10; ++val)
        sum += val;
    std::cout << "Suma del 1 al 10 inclusive es " << sum << std::endl;
    return 0;
}

• main tiene ámbito global.
• sum tiene ámbito de bloque dentro de main.
• val tiene ámbito local dentro del bucle for.

Ámbito anidado

#include <iostream>
using namespace std;
int reused = 42; // ámbito global
int main() {
    int unique = 0; // ámbito de bloque
    cout << reused << " " << unique << endl; // 42 0
    int reused = 0; // reutilización local oculta la global
    cout << reused << " " << unique << endl; // 0 0
    cout << ::reused << " " << unique << endl; // 42 0
    return 0;
}

Conversión de tipos de variables

C++ realiza conversiones implícitas bajo ciertas condiciones. Reglas clave:

• No bool a bool: 0 se convierte en false; cualquier otro valor en true.

  bool b = 42; // b es true

• bool a aritmético: true se convierte en 1, false en 0.

  bool b = true; int i = b; // i es 1

• Punto flotante a entero: trunca hacia cero.

  int i = 3.14; // i es 3

• Entero a punto flotante: se pierde la parte fraccionaria.

  int i = 3; double pi = i; // pi es 3.0

• Desbordamiento sin signo: el valor se ajusta módulo la base.

  unsigned char c = -1; // 255 en char de 8 bits

• Desbordamiento con signo: comportamiento indefinido.

Al mezclar enteros con y sin signo, valores negativos con signo pueden convertirse inesperadamente en grandes valores sin signo.

Variables register

Use la palabra clave register para sugerir que una variable de acceso frecuente se almacene en un registro de CPU. Los compiladores modernos suelen ignorar la pista, realizando sus propias optimizaciones.

register int i;

Comentarios

Los comentarios son ignorados por el compilador y sirven para documentar el código:

• Una línea – comienza con //.
• Varias líneas – delimitados por /* ... */.

/* Esto es un comentario */
/* Los comentarios en C++ también pueden
abarcar múltiples líneas */

Secuencias de escape

Las secuencias de escape representan caracteres no imprimibles o especiales:

Escape	Descripción
\n	Nueva línea
\t	Tabulación horizontal
\\	Barra invertida
\b	Retroceso
\r	Retorno de carro
\v	Tabulación vertical
\f	Salto de página
\a	Alerta (beep)
\"	Comilla doble
\'	Comilla simple
\?	Signo de interrogación

cout << '\n'; // nueva línea
cout << "\tguru99!\n"; // tab + texto + nueva línea

Secuencias generalizadas usan valores hexadecimales u octales:

\7  // beep
\12 // nueva línea
\40 // espacio
\x4D // 'M'

Resumen

• Las variables proporcionan almacenamiento con nombre y son tipadas.
• Tipos principales: int, double, char, float, string, bool.
• El ámbito define la visibilidad; los ámbitos anidados pueden sombrear nombres.
• Existen conversiones implícitas y explícitas pero deben usarse con cuidado.
• Las pistas register pueden mejorar el rendimiento pero son meramente consultivas.
• Los comentarios y secuencias de escape ayudan a la legibilidad y salida correcta.