⏩ Наследование позволяет создавать новые классы на основе существующих. Это способствует повторному использованию кода и организации иерархий классов. Базовый класс передаёт свои свойства и методы производному классу.

#include <iostream>
using namespace std;

// Базовый класс
class Animal {
public:
    void eat() {
        cout << "Eating..." << endl;
    }
};

// Производный класс
class Dog : public Animal {
public:
    void bark() {
        cout << "Barking..." << endl;
    }
};

int main() {
    Dog dog;
    dog.eat();  // Наследованный метод
    dog.bark(); // Собственный метод
    return 0;
}

Производный класс Dog наследует метод eat() от базового класса Animal.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

⬇️ Поток — это абстракция для работы с последовательностями данных, таких как файлы, консольный ввод/вывод и строки. Потоки позволяют читать и записывать данные в унифицированной форме.

🔵Для создания потока в C++ можно использовать стандартные библиотеки, такие как <iostream> для консольного ввода/вывода и <fstream> для работы с файлами.Пример создания потока для чтения из файла:

#include <fstream>
#include <iostream>
#include <string>

int main() {
    std::ifstream file("example.txt"); // Создание потока для чтения из файла
    std::string line;
    if (file.is_open()) {
        while (getline(file, line)) { // Чтение файла построчно
            std::cout << line << std::endl; // Вывод строки на консоль
        }
        file.close(); // Закрытие файла
    } else {
        std::cerr << "Не удалось открыть файл" << std::endl;
    }
    return 0;
}

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

🛑weak_ptr — это умный указатель, который предоставляет неблокирующую ссылку на объект, управляемый shared_ptr. Он не увеличивает счетчик ссылок на объект, что помогает избежать циклических зависимостей и утечек памяти.

🛑weak_ptr используется для проверки существования объекта и получения shared_ptr, если объект еще существует. Для этого применяется метод lock(), который возвращает shared_ptr.

#include <iostream>
#include <memory>

class Node {
public:
    std::weak_ptr<Node> next; // Слабая ссылка на следующий узел
};

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();

    node1->next = node2; // Установка слабой ссылки

    if (auto sharedNext = node1->next.lock()) {
        std::cout << "Next node is alive\n";
    } else {
        std::cout << "Next node is expired\n";
    }
}

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

📝 std::enable_if — это шаблон, используемый для реализации SFINAE (Substitution Failure Is Not An Error). Он позволяет включать или исключать функции и классы из перегрузки на этапе компиляции в зависимости от выполнения определённых условий.

#include <type_traits>

// Функция доступна только для целых типов
template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
foo(T value) {
    return value * 2;
}

// Функция доступна только для вещественных типов
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
foo(T value) {
    return value / 2;
}

➡️ std::enable_if помогает создавать более безопасный и гибкий код, контролируя доступность функций на основе типов.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

⚡️ Полиморфизм — это концепция объектно-ориентированного программирования, позволяющая объектам разных классов обрабатывать вызовы методов через общий интерфейс. Это достигается с помощью виртуальных функций и наследования.

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() { // Виртуальная функция
        cout << "Base class" << endl;
    }
};

class Derived : public Base {
public:
    void show() override { // Переопределение функции
        cout << "Derived class" << endl;
    }
};

int main() {
    Base* obj = new Derived();
    obj->show(); // Вызов функции Derived
    delete obj;
}

☑️ Полиморфизм позволяет использовать один интерфейс для работы с разными типами объектов, улучшая гибкость и расширяемость кода.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

💡 std::thread::detach используется для отделения потока от объекта std::thread, позволяя потоку продолжать выполнение независимо. После вызова detach, объект std::thread больше не связан с потоком и не может быть использован для управления им. Это полезно, когда поток должен работать в фоновом режиме, но важно помнить, что необходимо обеспечить завершение потока до завершения программы, иначе поведение будет неопределённым.

#include <iostream>
#include <thread>

void backgroundTask() {
    // Фоновая задача
    std::cout << "Фоновая задача выполняется\n";
}

int main() {
    std::thread t(backgroundTask);
    t.detach(); // Отделяем поток
    // Поток продолжает выполнение независимо
    std::cout << "Главный поток завершён\n";
    return 0;
}

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

👉 В C++ set и multiset — это контейнеры из библиотеки стандартных шаблонов (STL), которые хранят элементы в отсортированном порядке.

1⃣ set хранит уникальные элементы, не допускает дубликатов.

#include <set>
#include <iostream>

int main() {
    std::set<int> s = {1, 2, 3};
    s.insert(2); // Дубликат не добавится
    for (int x : s) {
        std::cout << x << " "; // Вывод: 1 2 3
    }
}

2⃣ multiset позволяет хранить дубликаты.

#include <set>
#include <iostream>

int main() {
    std::multiset<int> ms = {1, 2, 3};
    ms.insert(2); // Дубликат добавится
    for (int x : ms) {
        std::cout << x << " "; // Вывод: 1 2 2 3
    }
}

Основное отличие в том, что set не допускает дубликатов, а multiset — допускает.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

👉 map — это контейнер, реализующий ассоциативный массив, где каждый элемент представлен парой "ключ-значение". Ключи уникальны и автоматически сортируются.

👉 map основан на сбалансированном дереве поиска (обычно красно-черное дерево), что обеспечивает логарифмическое время доступа, вставки и удаления.

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> m;
    m[1] = "one"; // Вставка пары ключ-значение
    m[2] = "two";

    for (const auto& pair : m) {
        std::cout << pair.first << ": " << pair.second << std::endl; // Вывод ключа и значения
    }
}

map автоматически сортирует элементы по ключам.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

▶️ Union — это специальный тип данных, который позволяет хранить разные типы данных в одном и том же месте памяти. Все члены union используют одну и ту же область памяти, и в каждый момент времени может быть активно только одно значение.

#include <iostream>

union Data {
    int intValue;
    float floatValue;
    char charValue;
};

int main() {
    Data data;
    data.intValue = 10; // Устанавливаем значение int
    std::cout << "Int: " << data.intValue << std::endl;

    data.floatValue = 3.14f; // Перезаписываем значение float
    std::cout << "Float: " << data.floatValue << std::endl;

    return 0;
}

Union полезен для экономии памяти, но требует осторожности, так как изменение одного члена может затронуть другие.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

✅ Type traits — это шаблонные классы, предоставляющие информацию о типах во время компиляции. Они позволяют определять свойства типов, такие как принадлежность к числовым типам, возможность копирования и т.д. Используются для метапрограммирования и оптимизации.

#include <type_traits>

template<typename T>
void check() {
    // Проверка, является ли тип целочисленным
    if (std::is_integral<T>::value) {
        // Логика для целочисленных типов
    }
}

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

➡️ Inline функции позволяют компилятору вставлять код функции непосредственно в место её вызова, что может уменьшить накладные расходы на вызов функции и повысить производительность. Однако компилятор может проигнорировать запрос на inline, если функция слишком сложная или если её использование нецелесообразно.

#include <iostream>

inline int add(int a, int b) {
    // Простая inline функция для сложения двух чисел
    return a + b;
}

int main() {
    int result = add(3, 4);
    std::cout << "Result: " << result << std::endl;
}

Inline функции полезны для небольших, часто вызываемых функций.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

❗️Основное отличие между массивами и векторами заключается в управлении памятью и гибкости.

Массив — это статический контейнер с фиксированным размером, который задаётся при создании. Размер массива не может изменяться в процессе выполнения программы.

int arr[5] = {1, 2, 3, 4, 5}; // Статический массив из 5 элементов

Вектор — это динамический массив, который может изменять свой размер в процессе выполнения. Вектор автоматически управляет памятью, увеличивая или уменьшая её при добавлении или удалении элементов.

#include <vector>
std::vector<int> vec; // Инициализация вектора
vec.push_back(1); // Добавление элемента
vec.push_back(2); // Вектор автоматически увеличивает размер

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

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

std::thread::hardware_concurrency — это статическая функция, которая возвращает количество потоков, которые могут быть выполнены одновременно на текущем оборудовании. Это значение обычно соответствует количеству логических процессоров (ядер) в системе.

Функция полезна для оптимизации многопоточных программ, так как позволяет определить оптимальное количество потоков для выполнения задач. Если функция не может определить количество ядер, она возвращает 0.

#include <iostream>
#include <thread>

int main() {
    unsigned int numThreads = std::thread::hardware_concurrency();
    std::cout << "Number of concurrent threads supported: " << numThreads << std::endl;
    return 0;
}

Использование hardware_concurrency помогает избежать создания избыточного количества потоков, что может привести к снижению производительности из-за накладных расходов на переключение контекста.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

std::array — это контейнер из стандартной библиотеки, представляющий статический массив фиксированного размера. В отличие от обычных массивов, std::array предоставляет дополнительные методы, такие как size(), begin(), end(), и поддерживает итераторы, что делает его более удобным и безопасным в использовании.

Пример:

#include <array>
#include <iostream>

int main() {
    std::array<int, 3> arr = {1, 2, 3}; // Создание массива из 3 элементов
    std::cout << "Size: " << arr.size() << std::endl; // Размер массива
}

std::array хранит данные на стеке, что обеспечивает высокую производительность, и гарантирует отсутствие утечек памяти.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

😎std::unique_lock — это класс из стандартной библиотеки, предоставляющий более гибкий способ управления мьютексами по сравнению с std::lock_guard. Он позволяет захватывать и освобождать мьютекс вручную, поддерживает отложенную блокировку, а также может быть перемещён или передан в другие функции.

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

std::mutex mtx;

void task() {
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock); // Отложенная блокировка
    lock.lock(); // Захват мьютекса
    std::cout << "Critical section\n";
    lock.unlock(); // Освобождение мьютекса
}

std::unique_lock полезен в сценариях, где требуется более тонкий контроль над блокировками, например, при использовании условных переменных.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

✔️ Функция sort в STL (Standard Template Library) сортирует элементы в диапазоне, заданном итераторами. По умолчанию используется оператор <, но можно передать пользовательский компаратор для определения порядка сортировки.

#include <algorithm>
#include <vector>

std::vector<int> vec = {4, 2, 5, 1, 3};
std::sort(vec.begin(), vec.end()); // Сортировка по возрастанию

Для сортировки по убыванию можно использовать std::greater:

std::sort(vec.begin(), vec.end(), std::greater<int>());

Функция sort работает за время O(N log N) и использует гибридный алгоритм (обычно Introsort), сочетающий QuickSort, HeapSort и InsertionSort. Это делает её эффективной для большинства случаев.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

▶️ std::is_same — это шаблонный метафункция из библиотеки <type_traits>, которая проверяет, являются ли два типа одинаковыми. Возвращает std::true_type, если типы идентичны, и std::false_type в противном случае.

#include <type_traits>

bool result1 = std::is_same<int, int>::value; // true
bool result2 = std::is_same<int, double>::value; // false

std::is_same часто используется в шаблонном программировании для проверки типов на этапе компиляции. Это позволяет создавать специализированные реализации функций или классов в зависимости от типов.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

✅ STL (Standard Template Library) — это библиотека, предоставляющая набор шаблонных классов и функций для работы с контейнерами, алгоритмами и итераторами. Она является частью стандартной библиотеки и широко используется для упрощения работы с данными.

Основные компоненты STL:
- Контейнеры: vector, list, map, set и другие структуры для хранения данных.
- Алгоритмы: sort, find, copy и другие операции над данными.
- Итераторы: обеспечивают доступ к элементам контейнеров.

Пример:

#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {5, 3, 1, 4, 2};
    std::sort(vec.begin(), vec.end()); // Сортировка вектора
    return 0;
}

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

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

std::packaged_task — это шаблонный класс, который оборачивает вызываемый объект (функцию, лямбду или функтор) и позволяет асинхронно получить результат его выполнения через std::future. Используется для выполнения задач в отдельном потоке с последующим получением результата.

Пример:

#include <future>
#include <iostream>

int main() {
    std::packaged_task<int()> task([](){ return 42; });
    std::future<int> result = task.get_future();
    
    std::thread t(std::move(task)); // Запуск задачи в отдельном потоке
    t.join();
    
    std::cout << result.get(); // Получение результата: 42
    return 0;
}

std::packaged_task полезен для управления асинхронными операциями и синхронизации результатов между потоками.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

std::array — это контейнер STL, предоставляющий статический массив фиксированного размера с дополнительными методами для удобства работы. Для использования необходимо подключить заголовочный файл <array>.

#include <array>
#include <iostream>

int main() {
    std::array<int, 5> arr = {1, 2, 3, 4, 5};  // Создание массива на 5 элементов

    arr[0] = 10;  // Доступ к элементам по индексу
    std::cout << "First element: " << arr.front() << "\n";  // Первый элемент
    std::cout << "Last element: " << arr.back() << "\n";  // Последний элемент
    std::cout << "Size: " << arr.size() << "\n";  // Размер массива

    for (int i : arr) {
        std::cout << i << " ";  // Итерация по массиву
    }
    return 0;
}

std::array сочетает в себе безопасность и удобство STL с производительностью обычных массивов.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования