Что в С++11 поменяло С++ в лучшую сторону?

Ответ: C++11 — революционный стандарт, изменивший язык

C++11 был первой крупной ревизией стандарта (8 лет после C++03) и внёс радикальные изменения в язык и стандартную библиотеку. Это переломный момент в истории C++.

Основные улучшения

1. Rvalue references и Move семантика

Самое важное изменение.

// ❌ C++03: дорогое копирование
std::vector<int> create_vector() {
    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    return v;  // Копируется весь вектор!
}

std::vector<int> v = create_vector();  // Ещё одно копирование!

C++11 решение: rvalue references

// Move конструктор
std::vector<int>::vector(std::vector<int>&& other) noexcept {
    data = other.data;        // Забираем указатель
    size = other.size;        // Забираем размер
    other.data = nullptr;     // Зануляем исходный
    other.size = 0;
}

std::vector<int> v = create_vector();  // O(1) move, не копирование!

Результат:

• std::vector, std::string — move версии O(1)
• Исчезли ненужные копирования
• Производительность увеличилась радикально

2. auto и type deduction

// ❌ C++03: многословно
std::map<std::string, std::vector<int>>::iterator it = my_map.begin();

// ✅ C++11: компилятор определяет тип
auto it = my_map.begin();  // Типом выводится автоматически
auto v = std::vector<int>{1, 2, 3};
auto result = calculate();  // Тип зависит от return типа

Плюсы:

• Менее многословный код
• Меньше ошибок при изменении типов
• IDE может быстрее работать

3. Lambda функции

Функции как first-class citizens.

// ❌ C++03: нужны вспомогательные классы
struct Multiplier {
    int factor;
    Multiplier(int f) : factor(f) {}
    int operator()(int x) const { return x * factor; }
};

std::vector<int> v = {1, 2, 3, 4};
std::transform(v.begin(), v.end(), v.begin(), Multiplier(10));

// ✅ C++11: лямбды
int factor = 10;
std::transform(v.begin(), v.end(), v.begin(), 
    [factor](int x) { return x * factor; });

Колоссальное улучшение эргономики:

// Callbacks
server.on_connect([](Client& c) {
    std::cout << "Connected: " << c.ip << std::endl;
});

// Функциональное программирование
std::vector<int> evens;
std::copy_if(numbers.begin(), numbers.end(),
    std::back_inserter(evens),
    [](int n) { return n % 2 == 0; });

4. Умные указатели (Smart pointers)

// ❌ C++03: утечки памяти
void process() {
    MyObject* obj = new MyObject();
    // ... кода может быть исключение ...
    delete obj;  // Может не выполниться!
}

// ✅ C++11: RAII + умные указатели
void process() {
    std::unique_ptr<MyObject> obj(new MyObject());
    // ... код ...
}  // obj автоматически удаляется

std::shared_ptr<MyObject> shared = std::make_shared<MyObject>();
// Подсчёт ссылок, удалится когда все уходят

Революция в управлении памятью:

• unique_ptr — O(1) overhead, RAII
• shared_ptr — reference counting
• Исчезли утечки памяти в большинстве кода

5. Range-based for loop

// ❌ C++03: многословно
for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
    std::cout << *it << std::endl;
}

// ✅ C++11: просто и понятно
for (int x : v) {
    std::cout << x << std::endl;
}

for (auto& pair : my_map) {
    std::cout << pair.first << ": " << pair.second << std::endl;
}

6. Инициализация списков

// ❌ C++03: нельзя просто инициализировать контейнеры
int arr[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);

// ✅ C++11: uniform initialization
std::vector<int> v = {1, 2, 3};
std::map<std::string, int> ages = {{"Alice", 30}, {"Bob", 25}};
std::array<int, 3> arr = {1, 2, 3};

// Даже для пользовательских классов
class Point {
public:
    Point(int x, int y) {}
};

Point p = {10, 20};
std::vector<Point> points = {{0, 0}, {1, 1}, {2, 2}};

7. Multithreading библиотека

Наконец-то стандартная поддержка потоков!

// ✅ C++11: стандартные потоки
#include <thread>

std::thread t1(work_function, arg1);
std::thread t2([]{ std::cout << "Lambda in thread" << std::endl; });

t1.join();
t2.join();

// Синхронизация
std::mutex mtx;
{
    std::lock_guard<std::mutex> lock(mtx);
    // Критичная секция
}

std::condition_variable cv;
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, []{return ready;});

8. Constexpr

// ✅ C++11: вычисления во время компиляции
constexpr int fibonacci(int n) {
    return (n <= 1) ? n : fibonacci(n-1) + fibonacci(n-2);
}

int arr[fibonacci(10)];  // Размер вычислен в compile-time!

constexpr int result = fibonacci(10);  // 55 во время компиляции

9. nullptr

// ❌ C++03: NULL неоднозначен
void func(int x);
void func(void* ptr);

func(NULL);  // Какая перегрузка вызовется? Неясно!

// ✅ C++11: явный типаж для нулевого указателя
func(nullptr);  // Ясно, что это указатель

10. Variadic templates

// ✅ C++11: функции с произвольным числом аргументов
template<typename... Args>
void print(const Args&... args) {}

print(1, "hello", 3.14, true);

// std::tuple, std::make_tuple
auto t = std::make_tuple(1, "hello", 3.14);

Производительность

C++11 KO даже современным языкам в пыль:

// Move семантика
std::vector<std::vector<int>> matrix;
matrix.push_back(create_huge_vector());  // O(1) move

// До C++11 это было O(n) копирование!

Было ещё много улучшений

• static_assert — проверки типов на compile-time
• Right-angle brackets: std::vector<std::vector<int>> (не нужен пробел)
• Explicit conversion operators
• default и delete для специальных функций
• noexcept спецификатор
• override и final ключевые слова
• Raw string literals: R"(C:\path\to\file)"

Влияние на экосистему

// ДО C++11
std::auto_ptr<int> ptr(new int(5));  // Опасно, move undefined

// ПОСЛЕ C++11
std::unique_ptr<int> ptr(std::make_unique<int>(5));  // Безопасно
std::shared_ptr<int> ptr(std::make_shared<int>(5));  // Reference counting

Почему C++11 был революционным

✅ Move семантика — исчезли ненужные копирования ✅ Лямбды — код стал функциональным и читаемым ✅ Умные указатели — память управляется автоматически ✅ auto и type deduction — меньше boilerplate ✅ Стандартные потоки — наконец мультипоточность! ✅ Constexpr — метапрограммирование стало доступнее ⚠️ Сложность языка возросла — больше фич, больше граблей

Итог

C++11 переформатировал язык. Это был скачок эволюции, который привёл к:

• Более безопасному коду (умные указатели, move)
• Более читаемому коду (лямбды, range-for, auto)
• Более быстрому коду (move семантика, constexpr)
• Более стандартному коду (threads, smart pointers в stdlib)

Без C++11 современный C++ был бы совершенно другим и намного хуже.