Безопасность кода в C++26: Менеджеры ресурсов и висячие ссылки

const std::string& getDefaultName() {
    std::string name = "DefaultUser";
    return name;  // Возвращает ссылку на переменную, которая будет уничтожена!
}

vector<int>& createVector() {
    vector<int> result = {1, 2, 3};
    return result; // C++11 компиляторы могли, но не были обязаны предупреждать
}

std::string_view getName() {
    std::string name = "Alice";
    return name; // Опасно! Возвращаем view на временную строку
}

const std::vector<int>& getVector() {
    return std::vector<int>{1, 2, 3, 4, 5}; // Возвращаем ссылку на временный объект
}
 
void processData() {
    const auto& vec = getVector(); // vec теперь содержит висячую ссылку
    std::cout << vec[0]; // Неопределенное поведение!
}

class ConfigManager {
private:
    std::map<std::string, std::vector<uint8_t>> configs;
public:
    const std::vector<uint8_t>& findConfig(const std::string& name) {  
        auto it = configs.find(name);  
        if (it != configs.end()) 
            return it->second; 
        
        std::vector<uint8_t> defaultConfig = {1, 2, 3}; // Локальная переменная
        return defaultConfig; // Ошибка! Возвращаем ссылку на локальную переменную
    }  
};

std::function<int()> createCallback() {
    int multiplier = 10;
    return [&multiplier]() { return multiplier * 2; }; // Захват по ссылке
}
 
void executeCallback() {
    auto callback = createCallback(); // callback захватывает ссылку на multiplier
    int result = callback(); // Неопределенное поведение, multiplier уже не существует
}

std::vector<int> numbers = {1, 2, 3, 4, 5};
auto& firstElement = numbers[0];
numbers.push_back(6); // Может вызвать перевыделение памяти для вектора
std::cout << firstElement; // Потенциально висячая ссылка, если произошло перевыделение

std::vector<int> values = {1, 2, 3};
auto it = values.begin(); // Получаем итератор на первый элемент
 
values.push_back(4);      // Может вызвать перевыделение памяти
*it = 10;                 // Потенциально неопределённое поведение!

std::vector<std::vector<int>> matrix;
matrix.push_back({1, 2, 3});
 
auto& row = matrix[0];           // Ссылка на вектор внутри вектора
matrix.push_back({4, 5, 6});     // Может инвалидировать все ссылки
 
row.push_back(7);                // Неопределённое поведение

std::string_view extractPrefix(const std::string& input) {
    size_t pos = input.find(':');
    if (pos != std::string::npos) {
        return std::string_view(input.data(), pos);
    }
    return input; // Безопасно, пока input существует
}
 
std::string_view getPrefix() {
    std::string temp = "user:password";
    return extractPrefix(temp); // Ошибка! Возвращаем view на временный объект
}

class Database {
private:
    std::map<std::string, Record> records;
    
public:
    const Record& find(const std::string& id) {
        auto it = records.find(id);
        if (it != records.end()) {
            return it->second;
        }
        return Record{}; // Катастрофическая ошибка! Возврат ссылки на временный объект
    }
};

std::mutex mtx;
std::vector<BigObject> objects;
 
void thread1() {
    std::lock_guard<std::mutex> lock(mtx);
    auto& obj = objects[0]; // Получаем ссылку под защитой мьютекса
    
    // Выходим из критической секции, освобождая мьютекс
    
    // Другие потоки могут модифицировать вектор...
    
    obj.process(); // Возможно, уже висячая ссылка!
}

const std::vector<int>& getDefaultVector() {
    return {1, 2, 3}; // Теперь это ошибка компиляции, а не предупреждение
}

static std::vector<uint8_t> getDefaultConfig() {
    static std::vector<uint8_t> def {
        1, 2, 3, 4, 5, /* ... представим тысячи элементов ... */
    };
    return def;
}

static std::vector<uint8_t> getDefaultConfig() {
    // Создаётся временный массив на стеке
    const uint8_t tempArray[] = {1, 2, 3, 4, 5, ...}; 
    
    static std::vector<uint8_t> def(tempArray, tempArray + sizeof(tempArray)/sizeof(uint8_t));
    return def;
}

class ConfigManager {
private:
    std::map<std::string, std::vector<uint8_t>> configs;
    
    // Статический метод, возвращающий ссылку на статический объект
    static const std::vector<uint8_t>& getDefaultConfig() {
        static std::vector<uint8_t> def {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        return def;
    }
 
public:
    ConfigManager() {
        configs["database"] = {
                'h','o','s','t','=','l','o','c','a','l','h','o','s','t',';',
                'p','o','r','t','=','5','4','3','2'
        };
    }
 
    // Безопасный вариант метода findConfig
    const std::vector<uint8_t>& findConfig(const std::string& name) const {  
        auto it = configs.find(name);  
        if (it != configs.end()) 
            return it->second; 
        
        // Возвращаем ссылку на статический объект с долгим временем жизни
        return getDefaultConfig();
    }  
};

std::string_view extractDomain(const std::string& email) {
    size_t atPos = email.find('@');
    if (atPos != std::string::npos) {
        std::string domain = email.substr(atPos + 1); // Временная строка
        return domain; // В C++26 это ошибка компиляции
    }
    return {};
}

std::function<void()> createCallback() {
    int counter = 0;
    return [&counter]() { // Захват по ссылке
        counter++;
        std::cout << counter << std::endl;
    }; // В C++26 это вызовет ошибку компиляции
}

class UserManager {
private:
    std::map<int, User> users;
 
public:
    // Проблемный метод
    const User& getDefaultUser() const {
        return User{0, "Guest"}; // Ошибка в C++26: возврат ссылки на временный объект
    }
 
    // Правильные альтернативы:
    
    // 1. Вернуть копию объекта
    User getDefaultUserCopy() const {
        return User{0, "Guest"};
    }
 
    // 2. Поддерживать статический объект
    const User& getDefaultUserStatic() const {
        static const User defaultUser{0, "Guest"};
        return defaultUser;
    }
    
    // 3. Хранить объект в классе
    UserManager() {
        users[-1] = User{0, "Guest"};
    }
    
    const User& getDefaultUserFromMember() const {
        return users.at(-1);
    }
};

const std::string& selectPrefix(bool isAdmin) {
    return isAdmin ? "admin_" : std::string("user_"); // Ошибка только если isAdmin == false
}

class StringHolder {
private:
    std::string data;
public:
    StringHolder(const std::string& s) : data(s) {}
    
    const char* c_str() const {
        return data.c_str();
    }
};
 
const char* getConstCString() {
    StringHolder temp("Hello");
    return temp.c_str(); // В C++26 может быть обнаружено как ошибка
}

// До C++26 (схематично)
std::vector<int> createLargeVector() {
    const int tempArray[] = {1, 2, 3, /* ... тысячи элементов ... */}; // На стеке!
    return std::vector<int>(std::begin(tempArray), std::end(tempArray));
}
 
// C++26 (схематично)
std::vector<int> createLargeVector() {
    static const int tempArray[] = {1, 2, 3, /* ... тысячи элементов ... */}; // В статической памяти!
    return std::vector<int>(std::begin(tempArray), std::end(tempArray));
}

// Проблемный код (до C++26)
class ConfigManager {
private:
  std::map<std::string, std::vector<uint8_t>> configs;
 
public:
  ConfigManager() {
      configs["database"] = {
              'h','o','s','t','=','l','o','c','a','l','h','o','s','t',';',
              'p','o','r','t','=','5','4','3','2'
      };
  }
 
  const std::vector<uint8_t>& findConfig(const std::string& name) const {  
      auto it = configs.find(name);  
      if (it != configs.end()) 
          return it->second; 
 
      return {42}; // Возврат ссылки на временный объект!
  }  
};

// Исправленный код (C++26)
class ConfigManager {
private:
  std::map<std::string, std::vector<uint8_t>> configs;
  static const std::vector<uint8_t>& getDefaultConfig() {
      static std::vector<uint8_t> def {42};
      return def;
  }
 
public:
  ConfigManager() {
      configs["database"] = {
              'h','o','s','t','=','l','o','c','a','l','h','o','s','t',';',
              'p','o','r','t','=','5','4','3','2'
      };
  }
 
  const std::vector<uint8_t>& findConfig(const std::string& name) const {  
      auto it = configs.find(name);  
      if (it != configs.end()) 
          return it->second; 
 
      return getDefaultConfig();
  }  
};

std::vector<uint8_t> findConfig(const std::string& name) const {  
    auto it = configs.find(name);  
    if (it != configs.end()) 
        return it->second; 
 
    return {42};
}

std::optional<std::reference_wrapper<const std::vector<uint8_t>>> 
findConfig(const std::string& name) const {  
    auto it = configs.find(name);  
    if (it != configs.end()) 
        return std::reference_wrapper<const std::vector<uint8_t>>(it->second); 
 
    return std::nullopt;
}

void generateDefaultCertificate() {
    // Представим, что здесь 2MB бинарных данных для сертификата
    static std::vector<uint8_t> certificate {
        0x30, 0x82, 0x05, 0xA1, 0x30, 0x82, 0x03, 0x89, 
        // ... тысячи байтов сертификата ...
    };
    
    processCertificate(certificate);
}

// До C++26 - компилируется, но опасно
std::string_view extractUsername(const std::string& email) {
    std::string username = email.substr(0, email.find('@'));
    return username; // Висячая ссылка на уничтоженную строку!
}
 
// C++26 - ошибка компиляции
// Правильная версия:
std::string_view extractUsername(const std::string& email) {
    size_t atPos = email.find('@');
    if (atPos != std::string::npos) {
        return std::string_view(email.data(), atPos);
    }
    return email; // Безопасно, пока email существует
}

class ThreadSafeCache {
private:
    std::mutex mtx;
    std::map<std::string, std::shared_ptr<Resource>> resources;
 
public:
    // Вместо возврата ссылки, которая могла бы стать недействительной,
    // возвращаем shared_ptr, обеспечивающий управление временем жизни
    std::shared_ptr<Resource> getResource(const std::string& key) {
        std::lock_guard<std::mutex> lock(mtx);
        auto it = resources.find(key);
        if (it != resources.end()) {
            return it->second;
        }
        
        auto resource = std::make_shared<Resource>(key);
        resources[key] = resource;
        return resource;
    }
};

// Потенциально опасно при захвате по ссылке
template<typename Callback>
void registerCallback(Callback&& callback) {
    callbacks.push_back(std::forward<Callback>(callback));
}
 
// Более безопасный вариант, требующий захвата по значению
template<typename Callback>
void registerSafeCallback(Callback callback) {
    static_assert(std::is_copy_constructible_v<Callback>, 
                 "Callback must be copyable (captures by value)");
    callbacks.push_back(std::move(callback));
}

template<typename T>
class SafeVector {
private:
    std::vector<T> data;
    mutable std::atomic<size_t> accessVersion{0};
    
public:
    class SafeReference {
    private:
        const SafeVector* container;
        size_t version;
        size_t index;
        
    public:
        SafeReference(const SafeVector* c, size_t v, size_t i)
            : container(c), version(v), index(i) {}
            
        const T& get() const {
            if (container->accessVersion != version) {
                throw std::runtime_error("Container was modified!");
            }
            return container->data[index];
        }
    };
    
    SafeReference at(size_t index) const {
        if (index >= data.size()) {
            throw std::out_of_range("Index out of bounds");
        }
        return SafeReference(this, accessVersion.load(), index);
    }
    
    void push_back(const T& value) {
        data.push_back(value);
        accessVersion++;
    }
    
    // Другие методы...
};

void example() {
    std::string s1 = "hello";
    auto& s2 = s1;      // Заимствование по ссылке
    std::string s3 = s1; // Копирование, не перемещение
    
    std::cout << s1;    // В C++ допустимо, в отличие от Rust
}

std::string& get_ref() {
    std::string s = "hello";
    return s; // В C++26 это ошибка компиляции
}