Tipos y variables

Idea principal

Una variable es un nombre que apunta a un espacio en memoria donde guardas un valor. En C++ cada variable tiene un tipo: el tipo define que valores puede guardar, que operaciones puedes hacer y cuanta memoria ocupa.

int edad = 20;        // entero
double precio = 9.99; // decimal

La forma general de declarar es:

tipo nombre = valor;

Tipos fundamentales (los que mas vas a usar)

Enteros: numeros sin decimales

Tipo	Uso tipico	Ejemplo
`int`	Entero general (el mas comun)	`int contador = 0;`
`short`	Entero pequeno	`short dia = 15;`
`long`	Entero grande	`long poblacion = 8000000L;`
`long long`	Entero muy grande	`long long id = 9000000000LL;`

Tambien existen versiones sin signo (unsigned): solo guardan valores cero o positivos, pero pueden almacenar numeros mas grandes en el mismo espacio.

unsigned int puntos = 100;
unsigned char byte = 255;

En la universidad y en la mayoria de ejercicios, int es suficiente para contadores, indices y notas.

Decimales: numeros con parte fraccionaria

Tipo	Precision	Uso tipico
`float`	Menor (32 bits)	Graficos, sensores (cuando importa el tamano)
`double`	Mayor (64 bits)	El mas usado para calculos con decimales
`long double`	Aun mayor	Calculos cientificos (menos comun al inicio)

float temperatura = 36.5f;   // la 'f' indica que es float
double pi = 3.1415926535;

Recomendacion: usa double por defecto para decimales, salvo que te pidan float explicitamente.

Caracteres: una letra o simbolo

char guarda un solo caracter (1 byte en la mayoria de sistemas).

char letra = 'A';
char simbolo = '@';
char digito = '7';  // es el caracter '7', no el numero 7

Los caracteres van entre comillas simples ' '. Las cadenas de texto van entre comillas dobles " " (ver std::string mas abajo).

Valores especiales utiles:

char salto = '\n';  // salto de linea
char tab = '\t';    // tabulador

Booleanos: verdadero o falso

bool solo puede ser true o false. Se usa en condiciones, banderas y validaciones.

bool aprobado = true;
bool tieneError = false;

if (aprobado) {
    // ...
}

En C++, cualquier numero distinto de cero se considera “verdadero” en contextos antiguos, pero usa siempre true/false para que el codigo sea claro.

Texto: `std::string`

Para cadenas de texto (varias letras juntas) usa std::string de la libreria estandar:

#include <string>

std::string nombre = "Ana";
std::string saludo = "Hola, " + nombre;

char = un caracter. std::string = texto completo.

Como declarar e inicializar variables

C++ permite varias formas; estas son las mas comunes al empezar:

int a = 10;           // inicializacion con =
int b(20);            // inicializacion directa
int c{30};            // inicializacion con llaves (recomendada: evita perdidas de precision)
int d;                // sin inicializar (puede tener basura; evitalo al inicio)

Buena practica: inicializa siempre tus variables. Si no le das valor, puede contener “basura” de memoria.

Declarar varias del mismo tipo:

int x = 1, y = 2, z = 3;

Constantes: valores que no cambian

Si un dato no debe modificarse, marcalo como constante:

const double IVA = 0.16;
const int MAX_INTENTOS = 3;

const: el valor no se puede cambiar despues de asignarlo.
constexpr: constante que el compilador puede calcular en tiempo de compilacion (util para tamanos fijos y formulas simples).

constexpr int TAMANIO_TABLA = 10;

Por convencion, muchos programadores escriben constantes en MAYUSCULAS.

`auto`: dejar que el compilador infiera el tipo

auto le pide al compilador que deduzca el tipo a partir del valor:

auto edad = 20;           // el compilador deduce int
auto precio = 19.99;      // deduce double
auto nombre = std::string("Luis");

Util cuando el tipo es largo o obvio, pero al aprender es mejor escribir el tipo explicito hasta que lo domines.

Cual es el tamano de cada tipo?

El tamano exacto depende del sistema (32 o 64 bits), pero puedes consultarlo con sizeof:

#include <iostream>

int main() {
    std::cout << "int: " << sizeof(int) << " bytes\n";
    std::cout << "double: " << sizeof(double) << " bytes\n";
    std::cout << "char: " << sizeof(char) << " bytes\n";
    std::cout << "bool: " << sizeof(bool) << " bytes\n";
    return 0;
}

Valores tipicos en muchas PCs actuales:

Tipo	Tamano aproximado
`char`	1 byte
`bool`	1 byte
`int`	4 bytes
`float`	4 bytes
`double`	8 bytes
`long long`	8 bytes

Conversiones de tipo

A veces necesitas cambiar un valor de un tipo a otro.

Conversion implicita (automatica)

El compilador convierte solo en algunos casos:

int entero = 5;
double decimal = entero;  // int -> double (seguro)

Cuidado: de double a int pierdes decimales:

double pi = 3.99;
int truncado = pi;  // truncado vale 3, no 4

Conversion explicita (tu la pides)

double precio = 9.99;
int precioEntero = static_cast<int>(precio);  // forma moderna y clara

Prefiere static_cast sobre casts antiguos como (int)precio.

Operaciones basicas segun el tipo

int a = 10, b = 3;
int suma = a + b;       // 13
int resto = a % b;      // 1 (modulo, solo enteros)

double x = 10.0, y = 3.0;
double cociente = x / y;  // 3.333...

bool activo = true;
bool apagado = !activo;   // false (negacion)

Error comun: 10 / 3 en enteros da 3, no 3.33. Si quieres decimales, usa al menos un double:

double resultado = 10.0 / 3;  // 3.333...

Entrada y salida con variables

#include <iostream>
#include <string>

int main() {
    std::string nombre;
    int edad;

    std::cout << "Como te llamas? ";
    std::cin >> nombre;

    std::cout << "Cuantos anos tienes? ";
    std::cin >> edad;

    std::cout << "Hola " << nombre << ", tienes " << edad << " anos.\n";
    return 0;
}

std::cin lee desde la consola. El tipo de la variable determina como se interpreta lo que escribe el usuario.

Resumen rapido: que tipo usar

Necesitas guardar…	Tipo recomendado
Contador, edad, nota entera	`int`
Dinero, promedios, medidas	`double`
Si / no, validacion	`bool`
Una letra o simbolo	`char`
Nombre, mensaje, texto	`std::string`
Valor que no cambia	`const` o `constexpr`

Errores comunes al empezar

Confundir '7' con 7: el primero es char, el segundo es int.
No inicializar variables y luego usarlas.
Dividir enteros esperando decimales (5 / 2 da 2).
Mezclar tipos sin querer en expresiones (int + double funciona, pero conviene entender la conversion).
Usar float cuando double es mas preciso para calculos academicos.

Siguiente paso

Con los tipos claros, sigue con funciones para organizar tu codigo, o repasa sintaxis basica si necesitas reforzar la estructura de un programa.