C++11 marcó uno de los hitos más importantes en la modernización del lenguaje. Esta versión introdujo numerosas funciones modernas que simplifican la gestión de memoria, mejoran el rendimiento y permiten escribir un código más claro y seguro. En este artículo revisamos las novedades más importantes de C++11 mediante ejemplos prácticos.


1) La palabra clave auto

La palabra clave auto permite que el compilador deduzca automáticamente el tipo de una variable a partir de su expresión inicial. Esto hace que el código sea más limpio y fácil de leer.


auto x = 10;           // int
auto pi = 3.14;        // double
auto name = "Carlos";  // const char*

2) Bucle for basado en rangos (range-based for)

Introducido en C++11, ofrece una forma sencilla y segura de recorrer contenedores.


vector<int> valores = {1, 2, 3};

for (auto v : valores) {
    cout << v << endl;
}

3) nullptr

nullptr es un literal de puntero nulo seguro y con tipo definido, reemplazando al tradicional NULL.


int* p = nullptr;

4) Expresiones lambda

Las lambdas permiten definir funciones cortas y anónimas directamente en el lugar donde se necesitan.


auto greet = [](const string& name) {
    cout << "Hola, " << name;
};

greet("María");

5) Smart Pointers (unique_ptr, shared_ptr, weak_ptr)

Los smart pointers son una de las mejoras más importantes de C++11, ya que gestionan la memoria automáticamente y reducen drásticamente el riesgo de fugas de memoria.

unique_ptr


#include <memory>

unique_ptr<int> p = make_unique<int>(42);

shared_ptr


shared_ptr<string> s1 = make_shared<string>("Javier");
shared_ptr<string> s2 = s1; // el contador de referencias aumenta

weak_ptr


weak_ptr<string> wp = s1; // evita referencias cíclicas

6) Move Semantics (&&)

Move semantics permite transferir recursos en lugar de copiarlos, lo cual mejora considerablemente el rendimiento, especialmente con objetos temporales o grandes estructuras.


string a = "Hola Mundo";
string b = std::move(a); // se mueve en lugar de copiar

7) constexpr

constexpr permite evaluar expresiones en tiempo de compilación, lo que puede mejorar el rendimiento en tiempo de ejecución.


constexpr int cuadrado(int x) {
    return x * x;
}

int y = cuadrado(7);

8) std::array

Un reemplazo seguro y compatible con la STL para los arreglos clásicos de tamaño fijo.


#include <array>

array<int, 3> arr = {10, 20, 30};

9) enum class

Una versión fuertemente tipada de las enumeraciones tradicionales, evitando conflictos de nombres.


enum class Estado { EnLinea, FueraDeLinea, Ocupado };

Estado usuario = Estado::EnLinea;

10) Listas de inicialización

Simplifican la creación e inicialización de contenedores mediante {...}.


vector<string> nombres = {"Carlos", "María", "Javier"};

11) static_assert

Permite realizar comprobaciones en tiempo de compilación para detectar errores tempranos.


static_assert(sizeof(long) >= 8, "long debe tener al menos 8 bytes");

12) std::tuple

Permite almacenar múltiples valores de distintos tipos dentro de una sola estructura.


auto persona = make_tuple("Carlos", 28, 1.80);

13) Conclusión

C++11 introdujo características fundamentales que dieron forma al C++ moderno. Sus mejoras en rendimiento, seguridad y expresividad continúan influyendo en los estándares posteriores del lenguaje.

14) TL;DR

  • auto → deducción automática del tipo
  • range-based for → iteración simplificada
  • nullptr → puntero nulo más seguro
  • lambda → funciones anónimas en línea
  • smart pointers → gestión segura de memoria
  • move semantics → transferencias eficientes
  • constexpr → evaluación en tiempo de compilación
  • std::array, enum class, tuple → estructuras modernas
  • Compatible con Visual Studio 2022 y GCC