Разработчик C/C++ (Профессиональный уровень)

Экзаменационный билет №1

Теория

1. Что такое RAII и как он применяется в C++?
2. Какие виды умных указателей доступны в C++11 и в чём их отличие?

Практика

Напишите класс DynamicArray, который хранит динамический массив целых чисел. Реализуйте:

• Конструктор по умолчанию
• Конструктор с параметром размера
• Деструктор
• Move-семантику
• Метод push_back(int value)
• Оператор [] для доступа к элементу

Ответы:

Теория

1. RAII (Resource Acquisition Is Initialization) — это идиома, при которой ресурсы захватываются в конструкторе объекта и освобождаются в деструкторе. Это позволяет автоматически управлять ресурсами и обеспечивает безопасность при исключениях.
2. В C++11 доступны три типа умных указателей:
   • std::unique_ptr — владение одним указателем, не допускает копирования.
   • std::shared_ptr — разделяемое владение через счётчик ссылок.
   • std::weak_ptr — наблюдатель за shared_ptr, не увеличивает счётчик.

Практика

#include <iostream>
class DynamicArray {
private:
    int* data;
    size_t capacity;
    size_t size;

public:
    DynamicArray() : data(nullptr), capacity(0), size(0) {}

    explicit DynamicArray(size_t initialSize)
        : data(new int[initialSize]), capacity(initialSize), size(0) {}

    ~DynamicArray() { delete[] data; }

    DynamicArray(const DynamicArray&) = delete;
    DynamicArray& operator=(const DynamicArray&) = delete;

    DynamicArray(DynamicArray&& other) noexcept
        : data(other.data), capacity(other.capacity), size(other.size) {
        other.data = nullptr;
        other.capacity = 0;
        other.size = 0;
    }

    DynamicArray& operator=(DynamicArray&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            capacity = other.capacity;
            size = other.size;
            other.data = nullptr;
            other.capacity = 0;
            other.size = 0;
        }
        return *this;
    }

    void push_back(int value) {
        if (size >= capacity) {
            size_t newCapacity = capacity == 0 ? 1 : capacity * 2;
            int* newData = new int[newCapacity];
            for (size_t i = 0; i < size; ++i)
                newData[i] = data[i];
            delete[] data;
            data = newData;
            capacity = newCapacity;
        }
        data[size++] = value;
    }

    int& operator[](size_t index) {
        return data[index];
    }

    size_t getSize() const { return size; }
};

Экзаменационный билет №2

Теория

1. Что такое SFINAE и где он используется в шаблонном программировании?
2. Как работает механизм виртуальных функций в C++?

Практика

Напишите шаблонную функцию findMax, которая принимает два значения одного типа и возвращает большее из них. Функция должна работать только с типами, поддерживающими оператор <.

Ответы:

Теория

1. SFINAE (Substitution Failure Is Not An Error) — правило, позволяющее игнорировать ошибки подстановки типов в шаблонах без генерации ошибок компиляции. Используется для выбора наиболее подходящей версии шаблонной функции или класса.
2. Виртуальные функции реализуются через таблицу виртуальных функций (vtable), которая хранится в каждом объекте класса с виртуальными методами. При вызове виртуальной функции происходит динамическое связывание на основе указателя на vtable.

Практика

#include <iostream>
#include <type_traits>

template <typename T>
T findMax(T a, T b) {
    static_assert(std::is_less_than_comparable_v<T>, "Type must support operator <");
    return (a < b) ? b : a;
}

int main() {
    std::cout << findMax(5, 10) << std::endl;
    std::cout << findMax(3.14, 2.71) << std::endl;
    return 0;
}

Экзаменационный билет №3

Теория

1. Что такое move-семантика и как она реализуется в C++?
2. Чем отличаются std::vector и std::list в STL?

Практика

Напишите функцию splitString, принимающую строку и разделитель, и возвращающую вектор подстрок, разделённых этим символом. Используйте стандартные библиотеки.

Ответы:

Теория

1. Move-семантика позволяет перемещать ресурсы из одного объекта в другой вместо копирования. Реализуется через rvalue-ссылки (T&&) и специальные методы move-конструктора и move-оператора присваивания.
2. std::vector — динамический массив с произвольным доступом, эффективный для последовательных операций и добавления в конец. std::list — двусвязный список, эффективный для вставок и удалений в любом месте, но с медленным произвольным доступом.

Практика

#include <iostream>
#include <sstream>
#include <vector>
#include <string>

std::vector<std::string> splitString(const std::string& str, char delimiter) {
    std::vector<std::string> tokens;
    std::stringstream ss(str);
    std::string token;
    while (std::getline(ss, token, delimiter)) {
        tokens.push_back(token);
    }
    return tokens;
}

int main() {
    auto result = splitString("hello,world,test", ',');
    for (const auto& s : result)
        std::cout << s << std::endl;
    return 0;
}

Экзаменационный билет №4

Теория

1. Что такое memory_order в std::atomic и какие значения он может принимать?
2. Как использовать std::thread и std::mutex для многопоточности?

Практика

Напишите простой многопоточный счетчик, использующий 4 потока. Каждый поток должен инкрементировать общую переменную 1000 раз. Используйте std::mutex для защиты данных.

Ответы:

Теория

1. memory_order задаёт уровень упорядоченности доступа к памяти: memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst.
2. std::thread создаёт новый поток исполнения. std::mutex используется для защиты общих данных от одновременного доступа. Обычно применяются вместе с std::lock_guard или std::unique_lock.

Практика

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

std::mutex mtx;
int counter = 0;

void increment() {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        ++counter;
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 4; ++i)
        threads.emplace_back(increment);

    for (auto& t : threads)
        t.join();

    std::cout << "Counter: " << counter << std::endl;
    return 0;
}

Экзаменационный билет №5

Теория

1. Что такое пользовательские литералы в C++11 и как они применяются?
2. Как работают futures и promises в C++?

Практика

Напишите функцию, которая запускает асинхронное вычисление суммы двух чисел и возвращает результат через std::future.

Ответы:

Теория

1. Пользовательские литералы позволяют определять собственные суффиксы для чисел, строк и т.д., например: 123_km, "hello"s. Это упрощает работу с доменными типами.
2. std::future представляет результат асинхронной операции, а std::promise задаёт этот результат. Они обеспечивают обмен данными между потоками, особенно в сочетании с std::async.

Практика

#include <iostream>
#include <future>
#include <thread>

int asyncSum(int a, int b) {
    return a + b;
}

int main() {
    std::future<int> fut = std::async(std::launch::async, asyncSum, 10, 20);
    std::cout << "Result: " << fut.get() << std::endl;
    return 0;
}

Экзаменационный билет №6

Теория

1. Что такое placement new и когда он используется?
2. Как работают исключения в C++ и чем они отличаются от кодов возврата?

Практика

Напишите функцию, которая принимает указатель на массив целых чисел и его размер, и возвращает указатель на динамически выделенный массив, содержащий только чётные элементы исходного.

Ответы:

Теория

1. Placement new позволяет создавать объект в уже выделенной области памяти. Применяется в пулах памяти, контейнерах с контролем размещения и других случаях, где требуется точный контроль.
2. Исключения позволяют отделить обработку ошибок от основного потока выполнения. Они более выразительны, но могут быть дороже по производительности. Коды возврата требуют явной проверки, но дешевле по ресурсам.

Практика

#include <iostream>

int* extractEven(const int* arr, size_t size, size_t& outSize) {
    outSize = 0;
    for (size_t i = 0; i < size; ++i)
        if (arr[i] % 2 == 0)
            ++outSize;

    int* result = new int[outSize];
    size_t idx = 0;
    for (size_t i = 0; i < size; ++i)
        if (arr[i] % 2 == 0)
            result[idx++] = arr[i];

    return result;
}

int main() {
    size_t size = 8;
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
    size_t outSize;
    int* evenArr = extractEven(arr, size, outSize);

    for (size_t i = 0; i < outSize; ++i)
        std::cout << evenArr[i] << " ";
    std::cout << std::endl;

    delete[] evenArr;
    return 0;
}

Экзаменационный билет №7

Теория

1. Что такое memory leak и как его обнаружить и исправить?
2. Как организовать межпроцессное взаимодействие в Linux?

Практика

Реализуйте простой TCP-сервер на базе библиотеки Boost.Asio, который при подключении клиента отправляет ему строку "Hello from server!".

Ответы:

Теория

1. Memory leak — утечка памяти, возникает при неосвобождении выделенной памяти. Обнаруживается с помощью Valgrind, AddressSanitizer, LeakSanitizer.
2. Межпроцессное взаимодействие (IPC) в Linux реализуется через pipe, FIFO, сокеты, разделяемую память (shmget, mmap), семафоры и сигналы.

Практика

#include <boost/asio.hpp>
#include <iostream>

int main() {
    try {
        boost::asio::io_context io;
        boost::asio::ip::tcp::acceptor acceptor(io, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 12345));

        std::cout << "Server is running...\n";

        while (true) {
            boost::asio::ip::tcp::socket socket(io);
            acceptor.accept(socket);
            std::cout << "Client connected.\n";

            std::string message = "Hello from server!\n";
            boost::asio::write(socket, boost::asio::buffer(message));
        }
    } catch (std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

Экзаменационный билет №8

Теория

1. Что такое virtual inheritance и как он влияет на иерархию классов?
2. Как использовать std::variant и std::any в C++17?

Практика

Напишите шаблонную функцию printType, которая принимает параметр любого типа из заданного набора (int, double, std::string) и выводит его значение на экран.

Ответы:

Теория

1. Virtual inheritance используется для предотвращения множественного наследования базового класса. Позволяет иметь один экземпляр базового класса в иерархии, но усложняет инициализацию.
2. std::variant представляет тип-объединение, который может содержать значение одного из заданных типов. std::any — универсальный контейнер, способный хранить любой тип.

Практика

#include <iostream>
#include <variant>
#include <string>

void printType(const std::variant<int, double, std::string>& value) {
    std::visit([](const auto& v) { std::cout << v << std::endl; }, value);
}

int main() {
    printType(42);
    printType(3.14);
    printType(std::string("Hello"));
    return 0;
}

Экзаменационный билет №9

Теория

1. Что такое perfect forwarding и как он реализован в C++?
2. Как работают пользовательские операторы преобразования в C++?

Практика

Реализуйте простой собственный аллокатор для std::vector, который использует статический буфер фиксированного размера.

Ответы:

Теория

1. Perfect forwarding позволяет передавать аргументы функции без потери информации о ссылках и категориях выражений. Реализуется с помощью шаблонов и std::forward.
2. Пользовательские операторы преобразования (operator int(), operator bool()) позволяют явно или неявно преобразовывать объекты в другие типы. Неявное преобразование может быть опасным.

Практика

#include <iostream>
#include <vector>
#include <memory>

template<typename T, size_t N>
class StaticAllocator {
public:
    using value_type = T;

    StaticAllocator() = default;

    template<typename U>
    StaticAllocator(const StaticAllocator<U, N>&) noexcept {}

    T* allocate(size_t n) {
        if (n > N)
            throw std::bad_alloc();
        return reinterpret_cast<T*>(buffer);
    }

    void deallocate(T*, size_t) noexcept {}

private:
    alignas(T) char buffer[N * sizeof(T)];
};

int main() {
    StaticAllocator<int, 10> alloc;
    std::vector<int, StaticAllocator<int, 10>> vec(alloc);
    for (int i = 0; i < 10; ++i)
        vec.push_back(i);

    for (int v : vec)
        std::cout << v << " ";
    std::cout << std::endl;

    return 0;
}

Экзаменационный билет №10

Теория

1. Что такое ABI и почему важно сохранять совместимость интерфейсов?
2. Как использовать std::shared_lock и std::unique_lock для защиты данных?

Практика

Напишите многопоточную программу, в которой один поток записывает данные в очередь, а другой — считывает и выводит их.

Ответы:

Теория

1. ABI (Application Binary Interface) — соглашение о том, как данные и функции представлены в скомпилированном коде. Нарушение ABI приводит к ошибкам при использовании динамических библиотек.
2. std::shared_lock позволяет множественному чтению, но эксклюзивную запись. std::unique_lock предоставляет больше гибкости: поддерживает отложенную блокировку, попытки захвата и передачу владения мьютексом.

Практика

#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>

std::queue<int> dataQueue;
std::mutex mtx;
std::condition_variable cv;
bool done = false;

void producer() {
    for (int i = 0; i < 10; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::lock_guard<std::mutex> lock(mtx);
        dataQueue.push(i);
        cv.notify_one();
    }
    done = true;
    cv.notify_all();
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return !dataQueue.empty() || done; });
        if (dataQueue.empty() && done)
            break;
        while (!dataQueue.empty()) {
            std::cout << "Received: " << dataQueue.front() << std::endl;
            dataQueue.pop();
        }
    }
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);

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

    return 0;
}

Экзаменационный билет №11

Теория

1. Что такое lock-free программирование и как оно реализуется в C++?
2. Как использовать пользовательские аллокаторы в STL-контейнерах?

Практика

Напишите простую lock-free очередь на базе std::atomic с поддержкой одного producer и одного consumer.

Ответы:

Теория

1. Lock-free программирование — это подход, позволяющий организовать доступ к разделяемым данным без использования мьютексов. Реализуется через std::atomic и специальные примитивы памяти.
2. STL позволяет передавать пользовательский аллокатор в качестве шаблонного параметра. Это даёт контроль над распределением памяти, что полезно для оптимизации и интеграции с системными буферами.

Практика

#include <iostream>
#include <atomic>
#include <thread>

template<typename T, size_t Size>
class LockFreeQueue {
public:
    LockFreeQueue() : head(0), tail(0) {}

    bool push(const T& value) {
        size_t next_tail = (tail + 1) % Size;
        if (next_tail == head)
            return false; // очередь заполнена
        buffer[tail] = value;
        tail = next_tail;
        return true;
    }

    bool pop(T& value) {
        if (head == tail)
            return false; // очередь пуста
        value = buffer[head];
        head = (head + 1) % Size;
        return true;
    }

private:
    T buffer[Size];
    std::atomic<size_t> head;
    std::atomic<size_t> tail;
};

int main() {
    LockFreeQueue<int, 16> queue;

    std::thread producer([&] {
        for (int i = 0; i < 10; ++i)
            while (!queue.push(i))
                std::this_thread::yield();
    });

    std::thread consumer([&] {
        int value;
        for (int i = 0; i < 10; ++i) {
            while (!queue.pop(value))
                std::this_thread::yield();
            std::cout << "Consumed: " << value << std::endl;
        }
    });

    producer.join();
    consumer.join();

    return 0;
}

Экзаменационный билет №12

Теория

1. Что такое ADL (Argument-Dependent Lookup) и где он применяется?
2. Как работают пользовательские литералы в C++11?

Практика

Реализуйте собственный тип с перегруженным оператором вывода в поток и пользовательским литералом _kg.

Ответы:

Теория

1. ADL — это правило поиска функций, при котором компилятор учитывает пространства имён, связанные с типами аргументов. Используется, например, при перегрузке операторов.
2. Пользовательские литералы позволяют определять собственные суффиксы для чисел, строк и т.д.

Практика

#include <iostream>
#include <string>

struct Weight {
    double kg;
};

std::ostream& operator<<(std::ostream& os, const Weight& w) {
    return os << w.kg << " kg";
}

Weight operator"" _kg(long double value) {
    return Weight{ static_cast<double>(value) };
}

int main() {
    Weight w = 75.5_kg;
    std::cout << w << std::endl;
    return 0;
}

Экзаменационный билет №13

Теория

1. Что такое PIMPL-идиома и зачем она нужна?
2. Как использовать std::optional и когда он предпочтителен?

Практика

Реализуйте класс Person с использованием PIMPL-идиомы, который хранит имя и возраст.

Ответы:

Теория

1. PIMPL (Pointer to IMPLementation) — это способ скрытия реализации класса через указатель на внутреннюю структуру. Позволяет уменьшить зависимости и время перекомпиляции.
2. std::optional представляет значение, которое может отсутствовать. Предпочтителен вместо возврата NULL или использования исключений при частичной успешности операций.

Практика

// person.h
#pragma once
#include <string>
#include <memory>

class Person {
public:
    Person(const std::string& name, int age);
    ~Person();
    void print() const;

private:
    struct Impl;
    std::unique_ptr<Impl> pimpl;
};

// person.cpp
#include "person.h"
#include <iostream>

struct Person::Impl {
    std::string name;
    int age;
    Impl(const std::string& n, int a) : name(n), age(a) {}
};

Person::Person(const std::string& name, int age)
    : pimpl(std::make_unique<Impl>(name, age)) {}

Person::~Person() = default;

void Person::print() const {
    std::cout << "Name: " << pimpl->name << ", Age: " << pimpl->age << std::endl;
}

// main.cpp
#include "person.h"

int main() {
    Person p("Alice", 30);
    p.print();
    return 0;
}

Экзаменационный билет №14

Теория

1. Что такое tag dispatching и где он применяется?
2. Как работают итераторы в STL и какие категории существуют?

Практика

Реализуйте собственный итератор для массива фиксированного размера.

Ответы:

Теория

1. Tag dispatching — техника выбора перегрузки функции на основе метаданных времени компиляции. Применяется в STL для оптимизации алгоритмов в зависимости от категории итератора.
2. Итераторы предоставляют доступ к элементам контейнеров. Категории: input, output, forward, bidirectional, random access.

Практика

#include <iostream>

template<typename T, size_t N>
class FixedArray {
public:
    T data[N];

    class iterator {
    public:
        using value_type = T;
        using pointer = T*;
        using reference = T&;

        iterator(pointer ptr) : m_ptr(ptr) {}

        reference operator*() const { return *m_ptr; }
        pointer operator->() { return m_ptr; }

        iterator& operator++() { m_ptr++; return *this; }
        iterator operator++(int) { iterator tmp = *this; ++(*this); return tmp; }

        iterator& operator--() { m_ptr--; return *this; }
        iterator operator--(int) { iterator tmp = *this; --(*this); return tmp; }

        iterator operator+(size_t offset) const { return iterator(m_ptr + offset); }
        iterator operator-(size_t offset) const { return iterator(m_ptr - offset); }

        bool operator==(const iterator& other) const { return m_ptr == other.m_ptr; }
        bool operator!=(const iterator& other) const { return !(*this == other); }

    private:
        pointer m_ptr;
    };

    iterator begin() { return iterator(data); }
    iterator end() { return iterator(data + N); }
};

int main() {
    FixedArray<int, 5> arr = {{1, 2, 3, 4, 5}};
    for (auto it = arr.begin(); it != arr.end(); ++it)
        std::cout << *it << " ";
    std::cout << std::endl;
    return 0;
}

Экзаменационный билет №15

Теория

1. Что такое CRTP и как он используется в C++?
2. Как работают и чем отличаются lvalue и rvalue в C++?

Практика

Реализуйте шаблонный класс Counter, который считает количество созданных, удалённых и активных объектов типа T.

Ответы:

Теория

1. CRTP (Curiously Recurring Template Pattern) — это техника, при которой шаблонный класс наследуется от производного типа. Используется для статического полиморфизма, реализации Mixin-классов и оптимизации.
2. Lvalue — выражение, имеющее имя и адрес, может стоять слева от присваивания. Rvalue — временные значения, которые могут быть только справа. Rvalue-ссылки (T&&) используются для move-семантики.

Практика

#include <iostream>

template<typename T>
class Counter {
public:
    Counter() { ++created; ++active; }
    Counter(const Counter&) { ++created; ++active; }
    Counter(Counter&&) noexcept { ++created; ++active; }
    ~Counter() { --active; }

    static size_t createdCount() { return created; }
    static size_t activeCount() { return active; }

private:
    static size_t created;
    static size_t active;
};

template<typename T> size_t Counter<T>::created = 0;
template<typename T> size_t Counter<T>::active = 0;

struct MyType {};
using MyCounter = Counter<MyType>;

int main() {
    {
        MyCounter a, b;
        MyCounter c = std::move(b);
    }
    std::cout << "Created: " << MyCounter::createdCount() << std::endl;
    std::cout << "Active: " << MyCounter::activeCount() << std::endl;
    return 0;
}