Configuración Inicial y Cabeceras

En el desarrollo con C++, es una práctica estándar utilizar las versiones de C++ de las librerías clásicas de C. Por ejemplo, en lugar de stdio.h, se recomienda emplear cstdio, lo cual mejora la integración con el lenguaje.

Tipos de Datos y Gestión de Memoria

El manejo preciso de los tipos de datos es crítico para evitar desbordamientos o pérdida de precisión:

• int: Entero de 32 bits, comúnmente utilizado para rangos de hasta 2×10⁹. Se representa con %d.
• long long: Entero de 64 bits para valores que superan los 2×10⁹. Al asignar valores constantes grandes, se debe añadir el sufijo LL. Se usa %lld.
• double: Flotante de 64 bits. Es preferible sobre float debido a su precisión de 15-16 dígitos decimales.
• char: Almacena caracteres individuales. Es importante recordar que la diferencia entre minúsculas y mayúsculas en la tabla ASCII es de 32 unidades.
• bool: Valores lógicos true (1) y false (0).

Operadores y Expresiones

Además de los operadores aritméticos básicos (+, -, *, /, %), existen herramientas potentes como:

• Operadores de incremento/decremento: ++n (pre-incremento) y n++ (post-incremento).
• Operador ternario: Una forma compacta de if-else con la estructura condición ? valor_si_cierto : valor_si_falso.
• Operadores a nivel de bits: & (AND), | (OR), ^ (XOR), ~ (NOT), << y >> (desplazamientos). Tienen menor prioridad que los operadores aritméticos.

Entrada y Salida Formateada

Aunque cin y cout son comunes en C++, scanf y printf suelen ser más rápidos en contextos de alto rendimiento.

// Ejemplo de formato específico
printf("%05d", mi_entero); // Rellena con ceros a la izquierda hasta completar 5 dígitos
printf("%.3f", mi_double); // Limita la salida a 3 decimales

Funciones Matemáticas Comunes

Utilizando la cabecera cmath, se tiene acceso a:

• abs() / fabs(): Valor absoluto para enteros y flotantes.
• floor() y ceil(): Redondeo hacia abajo y hacia arriba.
• pow(base, exp): Potenciación.
• sqrt(): Raíz cuadrada.
• sin(), cos(), tan(): Funciones trigonométricas en radianes.

Estructuras de Control y Arreglos

El ordenamiento de datos es una tarea fundamental. Aquí se presenta una implementación del algoritmo de Burbuja con una lógica ligeramente modificada:

void ordenarBurbuja(int lista[], int tamano) {
    for (int paso = 0; paso < tamano - 1; paso++) {
        for (int k = 0; k < tamano - paso - 1; k++) {
            if (lista[k] > lista[k + 1]) {
                int auxiliar = lista[k];
                lista[k] = lista[k + 1];
                lista[k + 1] = auxiliar;
            }
        }
    }
}

Gestión de Cadenas y Memoria

Para manipular arreglos de caracteres, la librería cstring ofrece herramientas esenciales:

• memset(nombre_arreglo, valor, sizeof(nombre_arreglo)): Ideal para inicializar arreglos a 0 o -1.
• strlen(): Obtiene la longitud de la cadena sin contar el carácter nulo \0.
• strcmp(): Compara dos cadenas lexicográficamente.

Punteros y Referencias

En C++, las referencias permiten modificar variables originales sin la complejidad sintáctica de los punteros:

void incrementar(int &valor) {
    valor++; // Modifica directamente la variable original
}

Estructuras (structs) y Constructores

Las estructuras permiten agrupar datos de diferentes tipos. En C++, pueden incluir constructores para facilitar la inicialización:

struct Punto {
    int x, y;
    // Constructor con lista de inicialización
    Punto(int _x, int _y) : x(_x), y(_y) {}
    // Constructor por defecto
    Punto() : x(0), y(0) {}
};

Comparación de Números de Punto Flotante

Debido a la imprecisión binaria, nunca se deben comparar double usando ==. Se debe definir un margen de error (epsilon):

const double EPSILON = 1e-9;
bool sonIguales(double a, double b) {
    return abs(a - b) < EPSILON;
}

Análisis de Complejidad

Al diseñar algoritmos, la complejidad temporal se evalúa simplificando la expresión:

• Se omiten las constantes multiplicativas.
• Solo se conserva el término de mayor crecimiento (ej. en \(n^2 + n\), la complejidad es \(O(n^2)\)).
• La base de los logaritmos generalmente se ignora en la notación Big O.