Biblioteca STD en C++

La forma más explícita y segura es anteponer siempre std:: a cada elemento,

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numeros = {1, 2, 3};
    std::cout << "Ejemplo con std:: explícito:" << std::endl;
    for (std::size_t i = 0; i < numeros.size(); ++i) {
        std::cout << numeros[i] << " ";
    }
    return 0;
}

Esto evita conflictos de nombres si tu proyecto o alguna biblioteca externa define algo similar.

Otra opción es usar la instrucción using namespace std;, lo que elimina la necesidad de escribir std:: repetidamente

#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<int> numeros = {1, 2, 3};
    cout << "Ejemplo con using namespace std:" << endl;
    
    for (size_t i = 0; i < numeros.size(); ++i) {
        cout << numeros[i] << " ";
    }
    return 0;
}

Pero puede generar problemas en proyectos grandes por la introducción de nombres innecesarios en el espacio global

Una alternativa intermedia es declarar de manera específica las herramientas que usas,

#include <iostream>
#include <vector>

using std::cout;
using std::endl;
using std::vector;

int main() {
    vector<int> numeros = {1, 2, 3};
    
    cout << "Ejemplo con using específico:" << endl;
    for (size_t i = 0; i < numeros.size(); ++i) {
        cout << numeros[i] << " ";
    }
    return 0;
}

Esta última opción es preferible si trabajas en archivos pequeños o bien delimitados, ya que mantiene un buen equilibrio entre claridad y conveniencia.

• std::cin: Objeto para la entrada estándar (teclado).
• std::cout: Objeto para la salida estándar (pantalla).
• std::cerr: Objeto para la salida de errores.
• std::clog: Objeto para la salida de mensajes de registro.

• std::ifstream: Para leer datos de archivos.
• std::ofstream: Para escribir datos en archivos.
• std::fstream: Para leer y escribir en archivos.

• std::vector: Un contenedor que almacena elementos en un arreglo dinámico. Permite acceso rápido a los elementos y redimensionamiento dinámico.
• std::list: Un contenedor que implementa una lista doblemente enlazada, ideal para inserciones y eliminaciones rápidas en cualquier parte de la lista.
• std::deque: Un contenedor de doble extremo que permite acceso eficiente en ambos extremos del contenedor.

• std::set: Almacena elementos únicos en un árbol binario auto-balanceado. Permite búsquedas rápidas.
• std::map: Almacena pares clave-valor únicos. Similar a std::set, pero con asociación de claves y valores.
• std::unordered_set y std::unordered_map: Implementaciones basadas en tablas hash que ofrecen acceso constante promedio para operaciones de búsqueda, inserción y eliminación.

• std::stack: Una estructura de datos tipo pila que sigue el principio LIFO (Last In, First Out).
• std::queue: Una estructura de datos tipo cola que sigue el principio FIFO (First In, First Out).
• std::priority_queue: Una cola de prioridad que almacena elementos de manera que el elemento con mayor prioridad se extrae primero.

• std::sort: Ordena los elementos en un rango definido. Utiliza un algoritmo de ordenación eficiente basado en Quicksort.
• std::stable_sort: Ordena los elementos manteniendo el orden relativo de los elementos equivalentes.

• std::find: Busca un elemento en un rango. Devuelve un iterador al primer elemento encontrado o al final del rango si no se encuentra.
• std::binary_search: Busca un elemento en un rango ordenado.

• std::transform: Aplica una función a cada elemento en un rango y almacena el resultado en otro rango.
• std::accumulate: Acumula los valores en un rango utilizando una operación binaria.

• std::count: Cuenta el número de ocurrencias de un valor en un rango.
• std::all_of, std::any_of, std::none_of: Evalúan si todos, alguno, o ninguno de los elementos en un rango cumplen una condición.

• std::string: Una clase que facilita el manejo de cadenas de texto, proporcionando una serie de métodos para manipular y consultar cadenas de manera eficiente.

• std::pair: Una estructura de datos que almacena dos valores de tipos posiblemente diferentes. Se utiliza frecuentemente para devolver múltiples valores desde una función.
• std::tuple: Similar a std::pair, pero permite almacenar un número variable de elementos de diferentes tipos.

• std::optional: Representa un valor que puede estar presente o no. Se utiliza para indicar la ausencia de un valor sin usar punteros.

• std::variant: Permite almacenar uno de varios tipos de datos. Es una alternativa segura a los punteros de tipo y se utiliza para representar valores que pueden ser de diferentes tipos.