⚡️ Designated Initializers — именованная инициализация из C++20

Если устали помнить порядок полей в структурах и случайно их путать, то designated initializers могут решить эту проблему.

Designated initializers позволяют инициализировать структуры по именам полей, делая код более читаемым и безопасным.


✏️ Синтаксис:

struct Point {
    int x, y, z;
};

Point p{.x = 10, .y = 20, .z = 30};

🍴 Примеры использования:

struct Config {
    std::string host = "localhost";
    int port = 8080;
    bool ssl_enabled = false;
    int timeout_ms = 5000;
};

// Указываем только нужные поля
Config cfg{
    .host = "example.com",
    .ssl_enabled = true
}; // port и timeout_ms получат значения по умолчанию

🍴 С вложенными структурами:

struct Database {
    std::string connection_string;
    int max_connections = 10;
};

struct AppConfig {
    Database db;
    std::string log_level = "INFO";
};

AppConfig config{
    .db = {.connection_string = "postgresql://...", .max_connections = 20},
    .log_level = "DEBUG"
};

🍴 Функции с множеством опций:

struct DrawOptions {
    bool fill = false;
    int line_width = 1;
    std::string color = "black";
    float opacity = 1.0f;
};

void draw_rectangle(int x, int y, int w, int h, DrawOptions opts = {}) {
    // implementation
}

// Явно указываем только нужные опции
draw_rectangle(10, 20, 100, 50, {
    .fill = true,
    .color = "red",
    .opacity = 0.8f
});

Библиотека C/C++ разработчика

#буст

👁 std::variant — типобезопасный union

std::variant (C++17) — это union, который знает свой текущий тип и гарантирует безопасность.


🐤 Старый подход:

// C-style union — опасно!
union Data {
    int i;
    double d;
    char* str;
};

Data data;
data.i = 42;
std::cout << data.d; // ❌ Читаем не то, что записали

🐸 Современный подход:

std::variant<int, double, std::string> data;

data = 42;                    // Хранит int
data = 3.14;                  // Теперь хранит double
data = "hello";               // Теперь хранит string

// Безопасное получение значения
if (auto* val = std::get_if<int>(&data)) {
    std::cout << "int: " << *val << '\n';
}

🥨 Базовые операции:

std::variant<int, std::string, double> v;

// Установка значения
v = 100;
v = "text";
v.emplace<std::string>("constructed in place");

// Проверка текущего типа
std::cout << v.index(); // Индекс типа: 0, 1, или 2

if (std::holds_alternative<int>(v)) {
    std::cout << "Содержит int\n";
}

// Получение значения
try {
    auto val = std::get<int>(v); // Бросит std::bad_variant_access
} catch (const std::bad_variant_access&) {
    std::cerr << "Неверный тип!\n";
}

auto* ptr = std::get_if<std::string>(&v); // nullptr если не string

🐾 std::visit — главная фишка:

std::variant<int, double, std::string> v = 42;

// Обработка всех возможных типов
std::visit([](auto&& arg) {
    using T = std::decay_t<decltype(arg)>;
    
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "int: " << arg << '\n';
    } else if constexpr (std::is_same_v<T, double>) {
        std::cout << "double: " << arg << '\n';
    } else {
        std::cout << "string: " << arg << '\n';
    }
}, v);

🍪 Перегруженный visitor (C++17 трюк):

cpptemplate<class... Ts>
struct overloaded : Ts... { 
    using Ts::operator()...; 
};

template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;

// Элегантная обработка!
std::visit(overloaded{
    [](int i) { std::cout << "int: " << i << '\n'; },
    [](double d) { std::cout << "double: " << d << '\n'; },
    [](const std::string& s) { std::cout << "string: " << s << '\n'; }
}, v);

✏️ Пример: Обработка ошибок

template<typename T>
using Result = std::variant<T, std::string>; // Value или Error

Result<int> divide(int a, int b) {
    if (b == 0) return "Division by zero";
    return a / b;
}

auto result = divide(10, 0);
std::visit(overloaded{
    [](int value) { std::cout << "Result: " << value << '\n'; },
    [](const std::string& err) { std::cerr << "Error: " << err << '\n'; }
}, result);

❗️ Важно:

std::variant никогда не пустой (кроме исключительных ситуаций). Первый тип должен быть конструируемым по умолчанию.


❗️std::any:

Используйте std::variant когда набор типов известен. std::any — для действительно произвольных типов.


Библиотека C/C++ разработчика

#буст

🔍 FuzzTest: Фреймворк для фаззинг-тестирования в C++

FuzzTest (от Google) — это библиотека для фаззинг-тестирования C++ кода.

🐼 Что это такое?

FuzzTest — это фреймворк, который автоматически генерирует тысячи тестовых случаев для вашего кода, пытаясь найти крайние случаи, утечки памяти, крэши и другие баги. В отличие от классических unit-тестов, где вы вручную задаёте входные данные, фаззер делает это за вас.


🍴 Почему стоит использовать?

void MyTest(int x, const std::string& s) {
  EXPECT_TRUE(MyFunction(x, s));
}

FUZZ_TEST(MySuite, MyTest);

✅ Простой синтаксис
✅ Интеграция с GoogleTest
✅ Умная генерация данных — автоматически создаёт осмысленные входные данные для сложных типов: строк, контейнеров, структур


✏️ Пример использования

#include "fuzztest/fuzztest.h"

void ParseUrlTest(const std::string& url) {
  auto result = ParseUrl(url);
  // Проверяем, что не крашится на любых входных данных
  EXPECT_TRUE(result.has_value() || !result.has_value());
}

FUZZ_TEST(UrlParser, ParseUrlTest)
    .WithDomains(fuzztest::Arbitrary<std::string>());

‼️ Когда использовать?

✅ Парсеры и обработчики пользовательского ввода
✅ Сериализация/десериализация
✅ Криптографические функции
✅ Работа со сложными структурами данных
✅ API, которые должны быть устойчивы к любым входным данным


💌 Github

Библиотека C/C++ разработчика

📎 Где заказать курсовую по программированию

Курсовую по программированию легко заказать онлайн — сервисов действительно много.

Проблема в том, что не все они работают честно: бывает низкое качество, завышенные цены или несоблюдение сроков.

По ссылке — подборка площадок, которые в 2025 году показали стабильный результат.

➡️ Узнать, где лучше

🐸 Библиотека Go-разработчика