C++26: Что мы потеряли

enum E1 { e };
enum E2 { f };
bool b = e <= 3.7;  // Больше не компилируется в C++26
int k = f - e;      // Тоже не компилируется

bool b = +e <= 3.7;  // Работает, но выглядит не очень
int k = +f - e;      // Тоже вариант, хотя и сомнительный

int a[5] = {0, 1, 2, 3, 4};
int b[5] = {0, 1, 2, 3, 4};
 
if (a == b) {  // Было устаревшим в C++20, теперь недопустимо
    std::cout << "Массивы a и b имеют одинаковый адрес\n";
} else {
    std::cout << "Адреса массивов a и b различны\n";
}

#include <algorithm>
 
int a[5] = {0, 1, 2, 3, 4};
int b[5] = {0, 1, 2, 3, 4};
 
bool arrays_equal = std::equal(std::begin(a), std::end(a), 
                               std::begin(b), std::end(b));

#include <algorithm>
#include <ranges>
 
int a[5] = {0, 1, 2, 3, 4};
int b[5] = {0, 1, 2, 3, 4};
 
bool arrays_equal = std::ranges::equal(a, b);

int a[5];
int* b = a;
 
if (a == b) {  // По-прежнему корректно
    // Код выполнится
}

int a[5];
if (a == nullptr) {  // Допустимо, хотя результат всегда false
    // Этот блок никогда не выполнится
}

std::auto_ptr<int> p1(new int(42));
std::auto_ptr<int> p2 = p1;  // p1 теперь nullptr!

std::unique_ptr<int> p1 = std::make_unique<int>(42);
std::unique_ptr<int> p2 = std::move(p1);  // Явное перемещение

// Устаревший код
void foo() throw(std::runtime_error, std::bad_alloc);

// Современный код
void never_throws() noexcept;
void may_throw() noexcept(false);  // Или просто опустить спецификатор

enum Color { Red, Green, Blue };
double values[3] = {1.0, 2.0, 3.0};
double value = values[Blue];  // Работало, теперь не компилируется

enum Flag { First = 1, Second = 2, Third = 4 };
int mask = First | Second;  // По-прежнему работает
bool hasFirst = (mask & First) > 0;  // Не компилируется в C++26

bool hasFirst = (mask & static_cast<int>(First)) > 0;  // Правильный вариант

bool checkPassword(const char stored[8], const char entered[8]) {
    return stored == entered;  // Неверное сравнение, не компилируется в C++26
}

bool checkPassword(const char stored[8], const char entered[8]) {
    return std::memcmp(stored, entered, 8) == 0;  // Правильный вариант
    // или с C++20
    // return std::ranges::equal(stored, stored + 8, entered, entered + 8);
}

void process(int arr[10]) {
    std::cout << "Array version" << std::endl;
}
 
void process(int* ptr) {
    std::cout << "Pointer version" << std::endl;
}
 
// Вызов может изменить поведение в C++26
int main() {
    int values[10];
    process(values);  // Какая версия будет вызвана?
}

enum Color { Red, Green, Blue };
enum Size { Small, Medium, Large };
 
// Было:
int value = Red + Small; // Не компилируется в C++26
 
// Стало:
int value = static_cast<int>(Red) + static_cast<int>(Small);

enum class Color { Red, Green, Blue };
enum class Size { Small, Medium, Large };
 
// Правильный подход:
int value = static_cast<int>(Color::Red) + static_cast<int>(Size::Small);

template<typename EnumT>
constexpr auto to_underlying(EnumT e) noexcept {
    return static_cast<std::underlying_type_t<EnumT>>(e);
}
 
// Использование:
int value = to_underlying(Color::Red) + to_underlying(Size::Small);

// Было:
int a[5] = {1, 2, 3, 4, 5};
int b[5] = {1, 2, 3, 4, 5};
bool areEqual = (a == b); // Не компилируется в C++26
 
// Стало (C++03):
bool areEqual = std::equal(a, a + 5, b);
 
// Или еще лучше (C++20):
bool areEqual = std::ranges::equal(a, b);

int a[5];
int* ptr = a;
 
// По-прежнему допустимо:
bool sameAddress = (a == ptr);

// Вместо:
int values[10];
 
// Используйте:
std::array<int, 10> values;
// или
std::vector<int> values(10);

// Устаревший код:
enum Direction { North, East, South, West };
enum Magnitude { Low, Medium, High };
 
struct Movement {
    Direction dir;
    Magnitude mag;
    
    float getSpeed() const {
        // Использует арифметические операции с перечислениями
        return (dir + 1) * (mag + 0.5);
    }
    
    bool operator==(const Movement& other) const {
        char buffer1[2] = {static_cast<char>(dir), static_cast<char>(mag)};
        char buffer2[2] = {static_cast<char>(other.dir), static_cast<char>(other.mag)};
        return buffer1 == buffer2; // Сравнение массивов
    }
};

// Современный код:
enum class Direction { North, East, South, West };
enum class Magnitude { Low, Medium, High };
 
struct Movement {
    Direction dir;
    Magnitude mag;
    
    float getSpeed() const {
        // Явные преобразования типов
        return (static_cast<int>(dir) + 1) * (static_cast<int>(mag) + 0.5f);
    }
    
    bool operator==(const Movement& other) const {
        return dir == other.dir && mag == other.mag;
    }
};