El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Biblioteca Estándar de Plantillas (STL)

Siguiente ►
►

La Biblioteca Estándar de Plantillas (STL) es una poderosa colección de clases y funciones en C++ que proporciona estructuras de datos y algoritmos genéricos. La STL es una parte fundamental de la programación en C++ y permite a los desarrolladores escribir código más eficiente y reutilizable.

Contenidos

  1. Introducción a la STL
  2. Contenedores
    • Vectores
    • Listas
    • Conjuntos
    • Mapas
  3. Iteradores
  4. Algoritmos
  5. Funciones y Objetos Funcionales
  6. Ejercicios Prácticos

  1. Introducción a la STL

La STL se compone de tres componentes principales:

  • Contenedores: Estructuras de datos que almacenan objetos.
  • Iteradores: Objetos que apuntan a elementos dentro de los contenedores.
  • Algoritmos: Funciones que realizan operaciones sobre los contenedores.

  1. Contenedores

Vectores

Los vectores son arreglos dinámicos que pueden cambiar de tamaño. Son similares a los arreglos, pero con la ventaja de que pueden crecer y reducirse automáticamente.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec; // Crear un vector de enteros

    // Añadir elementos al vector
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);

    // Acceder a los elementos del vector
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " ";
    }

    return 0;
}

Listas

Las listas son contenedores de doble enlace que permiten la inserción y eliminación de elementos en cualquier posición.

#include <iostream>
#include <list>

int main() {
    std::list<int> lst; // Crear una lista de enteros

    // Añadir elementos a la lista
    lst.push_back(10);
    lst.push_back(20);
    lst.push_back(30);

    // Acceder a los elementos de la lista
    for (auto it = lst.begin(); it != lst.end(); ++it) {
        std::cout << *it << " ";
    }

    return 0;
}

Conjuntos

Los conjuntos son contenedores que almacenan elementos únicos en un orden específico.

#include <iostream>
#include <set>

int main() {
    std::set<int> s; // Crear un conjunto de enteros

    // Añadir elementos al conjunto
    s.insert(10);
    s.insert(20);
    s.insert(30);

    // Acceder a los elementos del conjunto
    for (auto it = s.begin(); it != s.end(); ++it) {
        std::cout << *it << " ";
    }

    return 0;
}

Mapas

Los mapas son contenedores que almacenan pares clave-valor. Las claves son únicas y se utilizan para acceder a los valores.

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> m; // Crear un mapa de enteros a cadenas

    // Añadir elementos al mapa
    m[1] = "Uno";
    m[2] = "Dos";
    m[3] = "Tres";

    // Acceder a los elementos del mapa
    for (auto it = m.begin(); it != m.end(); ++it) {
        std::cout << it->first << ": " << it->second << std::endl;
    }

    return 0;
}

  1. Iteradores

Los iteradores son objetos que permiten recorrer los elementos de un contenedor. Funcionan de manera similar a los punteros.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {10, 20, 30};

    // Usar un iterador para recorrer el vector
    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }

    return 0;
}

  1. Algoritmos

La STL proporciona una amplia gama de algoritmos que pueden aplicarse a los contenedores, como la búsqueda, la clasificación y la manipulación de elementos.

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {30, 10, 20};

    // Ordenar el vector
    std::sort(vec.begin(), vec.end());

    // Imprimir el vector ordenado
    for (int i : vec) {
        std::cout << i << " ";
    }

    return 0;
}

  1. Funciones y Objetos Funcionales

Las funciones y los objetos funcionales (functors) son componentes importantes de la STL que permiten la personalización de los algoritmos.

#include <iostream>
#include <vector>
#include <algorithm>

// Definir un functor
struct MultiplicarPorDos {
    void operator()(int &n) const {
        n *= 2;
    }
};

int main() {
    std::vector<int> vec = {1, 2, 3};

    // Usar el functor con el algoritmo for_each
    std::for_each(vec.begin(), vec.end(), MultiplicarPorDos());

    // Imprimir el vector modificado
    for (int i : vec) {
        std::cout << i << " ";
    }

    return 0;
}

  1. Ejercicios Prácticos

Ejercicio 1: Uso de Vectores

Instrucciones: Crea un programa que lea una serie de números enteros del usuario, los almacene en un vector y luego imprima los números en orden inverso.

Solución:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;
    int num;

    std::cout << "Introduce números enteros (0 para terminar): ";
    while (std::cin >> num && num != 0) {
        vec.push_back(num);
    }

    std::cout << "Números en orden inverso: ";
    for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
        std::cout << *it << " ";
    }

    return 0;
}

Ejercicio 2: Uso de Mapas

Instrucciones: Crea un programa que lea una serie de pares clave-valor del usuario, los almacene en un mapa y luego imprima todos los pares clave-valor.

Solución:

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> m;
    int key;
    std::string value;

    std::cout << "Introduce pares clave-valor (clave 0 para terminar): ";
    while (std::cin >> key && key != 0) {
        std::cin >> value;
        m[key] = value;
    }

    std::cout << "Pares clave-valor: ";
    for (const auto &pair : m) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

Conclusión

En esta sección, hemos explorado la Biblioteca Estándar de Plantillas (STL) en C++, cubriendo sus componentes principales: contenedores, iteradores, algoritmos y funciones. La STL es una herramienta poderosa que puede simplificar y mejorar significativamente la eficiencia de tu código. Asegúrate de practicar con los ejercicios proporcionados para consolidar tu comprensión de estos conceptos. En el próximo módulo, profundizaremos en las expresiones lambda, una característica avanzada de C++ que complementa el uso de la STL.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados