1. Cola (Queue)

La clase queue implementa una estructura FIFO (Primero en entrar, primero en salir). A contiunación, un ejemplo de uso básico.

#include <iostream>
#include <queue>

int main() {
    std::queue<int> cola;

    // Inserción de elementos en la cola
    cola.push(10);
    cola.push(20);

    // Consulta del elemento frontal
    std::cout << "Elemento frontal: " << cola.front() << std::endl;

    // Eliminación del elemento frontal
    cola.pop();

    // Consultas tras la eliminación
    std::cout << "Nuevo frontal: " << cola.front() << std::endl;
    std::cout << "Elemento trasero: " << cola.back() << std::endl;

    // Verificación del estado de la cola
    if (!cola.empty()) {
        std::cout << "La cola no está vacía. Tamaño: " << cola.size() << std::endl;
    }

    return 0;
}

Es posible utilizar tipos definiods por el usuario, como estructuras o clases, como parámetro de plantilla. Por ejemplo: queue<Estudiante>.

2. Pila (Stack)

La clase stack sigue un principio LIFO (Último en entrar, primero en salir).

#include <iostream>
#include <stack>

int main() {
    std::stack<int> pila;

    // Inserción en la cima de la pila
    pila.push(10);
    pila.push(20);

    // Acceso al elemento superior
    std::cout << "Cima actual: " << pila.top() << std::endl;

    // Remoción del elemento superior
    pila.pop();

    // Verificaciones posteriores
    if (pila.empty()) {
        std::cout << "La pila está vacía." << std::endl;
    } else {
        std::cout << "Tamaño actual: " << pila.size() << std::endl;
    }

    return 0;
}

3. Aritmética con números grandes

Para manejar números que exceden los límites de tipos primitivos, se pueden representar como cadenas y operar dígito a dígito.

#include <iostream>
#include <string>
#include <algorithm>

std::string sumarCadenasNumericas(const std::string& operando1, const std::string& operando2) {
    std::string sumaParcial;
    int acarreo = 0;
    int idx1 = operando1.size() - 1;
    int idx2 = operando2.size() - 1;

    while (idx1 >= 0 || idx2 >= 0 || acarreo > 0) {
        int digitoActual1 = (idx1 >= 0) ? (operando1[idx1] - '0') : 0;
        int digitoActual2 = (idx2 >= 0) ? (operando2[idx2] - '0') : 0;

        int totalTemporal = digitoActual1 + digitoActual2 + acarreo;
        acarreo = totalTemporal / 10;
        int residuo = totalTemporal % 10;

        sumaParcial.push_back(static_cast<char>(residuo + '0'));

        idx1--;
        idx2--;
    }

    std::reverse(sumaParcial.begin(), sumaParcial.end());
    return sumaParcial;
}

int main() {
    std::string valorGrande1 = "99999999999999999999";
    std::string valorGrande2 = "1";

    std::string resultado = sumarCadenasNumericas(valorGrande1, valorGrande2);
    std::cout << "Resultado de la suma: " << resultado << std::endl;

    return 0;
}

4. Paso por referencia y puntero

Para modificar variables fuera del ámbito de una función, se utilizan punteros o referencias.

Mediante punteros:

#include <iostream>

void intercambiarPorPunteros(int* ptrA, int* ptrB) {
    int valorTemporal = *ptrA;
    *ptrA = *ptrB;
    *ptrB = valorTemporal;
}

int main() {
    int x = 5;
    int y = 10;

    intercambiarPorPunteros(&x, &y);
    std::cout << "x: " << x << ", y: " << y << std::endl;

    return 0;
}

Mediante referencias:

#include <iostream>

void intercambiarPorReferencias(int& refA, int& refB) {
    int valorTemporal = refA;
    refA = refB;
    refB = valorTemporal;
}

int main() {
    int m = 15;
    int n = 20;

    intercambiarPorReferencias(m, n);
    std::cout << "m: " << m << ", n: " << n << std::endl;

    return 0;
}