Control preciso de decimales en C++ requiere comprendre las herramientas estándar. La función setprecision ajusta dígitos significativos, pero su comportamiento cambia al combinarla con fixed:

#include <iomanip>
double valor = 3.14159265;
// Muestra 2 dígitos significativos: 3.1
std::cout << std::setprecision(2) << valor << std::endl;
// Formato de punto fijo con 4 decimales: 3.1416
std::cout << std::fixed << std::setprecision(4) << valor;

Existen tres enfoques equivalentes para fijar decimales:

std::cout << std::fixed << std::setprecision(3) << valor;
std::cout.setf(std::ios::fixed, std::ios::floatfield);
std::cout << std::setprecision(3) << valor;
std::cout << std::setiosflags(std::ios::fixed) << std::setprecision(3) << valor;

Para redondeo matemático, ajuste el valor antes de convertir:

double entrada;
std::cin >> entrada;
int resultado = (entrada >= 0) ? static_cast<int>(entrada + 0.5) 
                               : static_cast<int>(entrada - 0.5);

El algoritmo de selección optimizado procesa mínimo y máximo simultáneamente:

void OrdenarSeleccion(int* datos, size_t tamano) {
    size_t inicio = 0;
    size_t fin = tamano - 1;
    
    while (inicio < fin) {
        size_t indiceMin = inicio;
        size_t indiceMax = inicio;
        
        for (size_t i = inicio; i <= fin; ++i) {
            if (datos[i] < datos[indiceMin]) indiceMin = i;
            if (datos[i] > datos[indiceMax]) indiceMax = i;
        }
        
        std::swap(datos[inicio], datos[indiceMin]);
        
        if (indiceMax == inicio) 
            indiceMax = indiceMin;
            
        std::swap(datos[fin], datos[indiceMax]);
        inicio++;
        fin--;
    }
}

Manejo seguro de cadenas con getline:

char buffer[100];
std::cin.getline(buffer, sizeof(buffer)); // Versión para char*
std::string texto;
std::getline(std::cin, texto); // Versión para std::string

Implementación segura de arreglos dinámicos mediante clases:

class Arreglo {
private:
    int* elementos;
    size_t longitud;
public:
    Arreglo() : elementos(nullptr) {
        std::cin >> longitud;
        elementos = new int[longitud];
        for (size_t i = 0; i < longitud; ++i) {
            std::cin >> elementos[i];
        }
    }
    ~Arreglo() {
        delete[] elementos;
    }
    // Métodos de acceso omitidos por brevedad
};

Las funciones lower_bound y upper_bound requieren colecciones ordenadas:

std::vector<int> numeros = {1, 3, 5, 7, 9};
auto it_inferior = std::lower_bound(numeros.begin(), numeros.end(), 6);
// it_inferior apunta a 7 (primer valor >= 6)
auto it_superior = std::upper_bound(numeros.begin(), numeros.end(), 6);
// it_superior también apunta a 7 (primer valor > 6)

Nota crucial: Estas operaciones binarias exigen que el contenedor esté previamente ordenado. Para secuencias descendentes, se debe proporcionar un comparador personalizado como tercer argumento.