Evolución y Contexto de C++

El lenguaje C++ nació de la necesidad de dotar al lenguaje C de capacidades de abstracción más potentes sin sacrificar el rendimiento. Diseñado por Bjarne Stroustrup en los Laboratorios Bell a partir de 1979, inicialmente fue conocido como "C con clases". En 1983, el lenguaje fue renombrado oficialmente como C++ para reflejar su naturaleza evolutiva (el operador de incremento ++).

Desde su primera estandarización en 1998 (C++98), el lenguaje ha pasado por hitos críticos:

• C++11: Una revolución que introdujo expresiones lambda, auto, y la semántica de movimiento.
• C++17/20: Introdujerno mejoras de metaprogramación como if constexpr y grandes características como conceptos (Concepts) y módulos.
• C++23: La versión más reciente que refina la biblioteca estándar y mejora la compatibilidad con el desarrollo moderno.

Gestión de Ámbitos: Namespaces

En proyectos de gran envergadura, es común que distintos módulos utilicen los mismos nombres para variables o funciones. Los espacios de nombres (namespace) permiten agrupar identificadores bajo un nombre único para evitar colisiones en el ámbito global.

#include <iostream>

namespace MotorGrafico {
    int resolucion = 1080;
    void inicializar() {
        std::cout << "Motor inicializado a " << resolucion << "p" << std::endl;
    }
}

namespace MotorSonido {
    int resolucion = 44100; // No hay conflicto con MotorGrafico
    void inicializar() {
        std::cout << "Audio configurado a " << resolucion << "Hz" << std::endl;
    }
}

int main() {
    MotorGrafico::inicializar();
    MotorSonido::inicializar();
    return 0;
}

Existen tres formas principales de acceder a un miembro de un namespace:

1. Acceso calificado: Namespace::Miembro (Recomendado por claridad).
2. Declaración using: using Namespace::Miembro; (Expone un solo elemento).
3. Directiva using: using namespace Namespace; (Expone todo el contenido; usar con precaución).

Entrada y Salida de Datos

C++ utiliza la biblioteca <iostream> para el manejo de flujos de datos. A diferencia de C, C++ identifica automáticamente el tipo de dato mediante la sobrecarga de operadores.

#include <iostream>
#include <string>

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

    std::cout << "Introduce tu nombre y edad: ";
    std::cin >> nombre >> edad;

    std::cout << "Hola " << nombre << ", tienes " << edad << " años." << std::endl;

    return 0;
}

Parámetros por Defecto

C++ permite asignar valores predeterminados a los argumentos de una función. Si el programador no proporciona un valor al llamar a la función, se utiliza el valor por defecto.

Regla importante: Los parámetros por defecto deben definirse de derecha a izquierda. No se pueden dejar huecos en la declaración.

void configurarServidor(std::string ip, int puerto = 8080, int timeout = 30) {
    std::cout << "Conectando a " << ip << ":" << puerto << " (Timeout: " << timeout << "s)" << std::endl;
}

int main() {
    configurarServidor("127.0.0.1");             // Usa puerto 8080 y timeout 30
    configurarServidor("192.168.1.1", 443);      // Usa timeout 30
    return 0;
}

Sobrecarga de Funciones

Es posible definir múltiples funciones con el mismo nombre siempre que su firma (parámetros) sea distinta. El compilador decide cuál ejecutar basándose en los argumentos proporcionados.

int calcular(int a, int b) { return a + b; }
double calcular(double a, double b) { return a * b; }
long calcular(long a) { return a * a; }

// Nota: Cambiar solo el tipo de retorno no es suficiente para sobrecargar.

Referencias en C++

Una referencia es un alias para una variable ya existente. A diferencia de los punteros, una referencia no puede ser nula y no puede ser reasignada para referenciar otro objeto después de su inicialización.

void duplicar(int& valor) {
    valor *= 2; // Modifica directamente la variable original
}

int main() {
    int numero = 50;
    int& alias = numero;
    
    duplicar(numero);
    std::cout << "Nuevo valor: " << alias << std::endl; // Imprime 100
    return 0;
}

Comparativa: Punteros vs. Referencias

Funciones Inline

La palabra clave inline sugiere al compilador que reemplace la llamada a la función por el cuerpo de la misma. Esto elimina la sobrecarga de tiempo de ejecución asociada con la creación de marcos de pila (stack frames) en funciones pequeñas y frecuentes.

inline int cuadrado(int n) {
    return n * n;
}

Es ideal para funciones de una sola línea, pero el compilador puede ignorar la sugerencia si la función es compleja o recursiva.

Uso de nullptr

En C antiguo, NULL se definía comúnmente como 0. Esto causaba ambigüedades en la sobrecarga de funciones (¿se llama a la versión entera o a la versión puntero?). C++11 introdujo nullptr, un literal que representa estrictamente un puntero nulo.

void test(int n) { std::cout << "Entero" << std::endl; }
void test(int* p) { std::cout << "Puntero" << std::endl; }

int main() {
    test(0);       // Llama a test(int)
    test(nullptr); // Llama a test(int*) con total seguridad
    return 0;
}