C/C++ | Вопросы собесов

🤔 Что в себе хранит указатель? Указатель (pointer) — это переменная, которая хранит адрес другой переменной в памяти. По сути, указатель "указывает" на местоположение другого значения. 🚩Основные аспекты указателей 🟠Адрес памяти Указатель хранит числовое значение, которое представляет адрес ячейки памяти. Этот адрес указывает на начальную позицию объекта, на который ссылается указатель. 🟠Тип данных Указатели типизированы. Тип указателя указывает на тип данных, который находится по адресу. Это важно для правильной интерпретации данных, хранящихся по адресу. 🚩Объявление и инициализация указателей 🟠Объявление Указатель объявляется с использованием символа * после типа данных.

    
              int* ptr; // Указатель на целое число
   double* dptr; // Указатель на число с плавающей  {}
    

🟠Инициализация Указатели могут быть инициализированы адресом существующей переменной с помощью оператора & (адресной операции).

    
              int value = 42;
   int* ptr = &value; // ptr хранит адрес переменной  {}
    

Пример использования указателей

    
        #include <iostream>

int main() {
    int value = 42;
    int* ptr = &value; // ptr хранит адрес переменной value

    std::cout << "Значение value: " << value << std::endl; // Вывод: 42
    std::cout << "Адрес value: " << &value << std::endl; // Вывод: Адрес переменной value
    std::cout << "Значение, на которое указывает ptr: " << *ptr << std::endl; // Вывод: 42
    std::cout << "Адрес, хранимый в ptr: " << ptr << std::endl; // Вывод: Адрес переменной value

    // Изменение значения через указатель
    *ptr = 10;
    std::cout << "Новое значение value: " << value << std::endl; // Вывод: 10

    return 0;
}{}
    

🚩Операции с указателями 🟠Доступ к значению по указателю Используя оператор разыменования *, можно получить или изменить значение, на которое указывает указатель.

    
              int value = 42;
   int* ptr = &value;
   *ptr = 10; // Изменение значения value через  {}
    

🟠Адресные операции & оператор используется для получения адреса переменной. * оператор используется для разыменования указателя. 🟠Арифметика указателей Указатели поддерживают арифметические операции, такие как сложение и вычитание, что позволяет перемещаться по массивам.

    
              int arr[] = {1, 2, 3, 4, 5};
   int* ptr = arr;
   std::cout << *(ptr + 1) << std::endl; // Вывод: 2 (второй элемент массива{}
    

🚩Типы указателей 🟠Указатель на объект Указатель, который хранит адрес конкретного объекта.

    
              int value = 42;
   int* ptr = &value;{}
    

🟠Указатель на массив Указатель может указывать на первый элемент массива, и арифметика указателей позволяет перемещаться по массиву.

    
           int arr[] = {1, 2, 3, 4, 5};
   int* ptr = arr;{}
    

🟠Указатель на функцию Указатель, который хранит адрес функции.

    
              void func() {
       std::cout << "Hello, World!" << std::endl;
   }

   void (*funcPtr)() = func;
   funcPtr(); // Вызов функции через указатель{}
    

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как работает new? Оператор new в C++ выделяет память из кучи (heap) для хранения объекта и возвращает указатель на эту область памяти. Помимо выделения памяти, new также вызывает конструктор объекта, если он определен. В случае, если не хватает памяти для выделения, new выбрасывает исключение std::bad_alloc. Для освобождения памяти, выделенной через new, необходимо использовать оператор delete. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Какие виды конструкторов могут быть у класса? 🟠Конструктор по умолчанию (Default Constructor) Без параметров, создается автоматически компилятором, если не задан.

    
           class MyClass {
   public:
       MyClass() {}
   };{}
    

🟠Параметризованный конструктор (Parameterized Constructor) Принимает параметры для инициализации объекта.

    
           class MyClass {
   private:
       int x;
   public:
       MyClass(int value) : x(value) {}
   };{}
    

🟠Конструктор копирования (Copy Constructor) Создает копию существующего объекта.

    
           class MyClass {
   private:
       int x;
   public:
       MyClass(const MyClass &other) : x(other.x) {}
   };{}
    

🟠Конструктор перемещения (Move Constructor) Перемещает ресурсы из временного объекта.

    
           class MyClass {
   private:
       int* data;
   public:
       MyClass(MyClass&& other) noexcept : data(other.data) {
           other.data = nullptr;
       }
   };{}
    

🟠Делегирующий конструктор (Delegating Constructor) Вызывает другой конструктор того же класса.

    
           class MyClass {
   private:
       int x, y;
   public:
       MyClass(int value) : MyClass(value, 0) {}
       MyClass(int value1, int value2) : x(value1), y(value2) {}
   };{}
    

🟠Явный конструктор (Explicit Constructor) Помечен explicit для предотвращения неявных преобразований.

    
           class MyClass {
   public:
       explicit MyClass(int value) {}
   };{}
    

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какая сложность операции вставки у list? Вставка в list имеет сложность O(1), так как требуется лишь обновление ссылок соседних узлов. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Расскажите про ключевое слово _fastcall? Это соглашение о вызове функций, используемое в некоторых компиляторах C и C++ (например, Microsoft Visual C++), которое указывает, что параметры функции должны передаваться через регистры, а не через стек. Это может привести к более быстрой работе программы, так как доступ к регистрами обычно быстрее, чем доступ к стеку. 🚩Основные характеристики 🟠Передача аргументов через регистры _fastcall передает первые два целочисленных аргумента (например, int, char, long) через регистры ECX и EDX на архитектуре x86. Остальные аргументы передаются через стек. 🟠Обратная совместимость _fastcall обеспечивает совместимость с другими соглашениями о вызове, но это может потребовать дополнительных усилий для обеспечения совместимости при смешивании разных соглашений о вызове в одном проекте. 🟠Оптимизация производительности Передача аргументов через регистры уменьшает накладные расходы, связанные с использованием стека, что может улучшить производительность в функциях, которые вызываются часто или требуют высокой производительности.

    
        #include <iostream>

// Функция, использующая соглашение о вызове _fastcall
int __fastcall add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(5, 3);
    std::cout << "Result: " << result << std::endl; // Вывод: Result: 8
    return 0;
}{}
    

🚩Примечания и ограничения 🟠Платформенная зависимость _fastcall специфичен для архитектуры x86 и поддерживается не всеми компиляторами. На x64 используется другое соглашение о вызове, и _fastcall не применим. 🟠Совместимость с другими соглашениями о вызове Если вы используете _fastcall вместе с другими соглашениями о вызове (например, __cdecl, __stdcall), нужно быть осторожным, чтобы избежать ошибок при вызове функций с разными соглашениями о вызове. 🟠Использование в современных проектах В современных проектах использование _fastcall редко необходимо, так как современные компиляторы достаточно умны, чтобы автоматически оптимизировать вызовы функций, используя подходящие соглашения о вызове. В большинстве случаев вручную указывать _fastcall нет необходимости.

    
        #include <iostream>

// Проверка платформы
#ifdef _M_IX86 // Если используется компилятор для архитектуры x86
int __fastcall add(int a, int b) {
    return a + b;
}
#else
int add(int a, int b) {
    return a + b;
}
#endif

int main() {
    int result = add(5, 3);
    std::cout << "Result: " << result << std::endl; // Вывод: Result: 8
    return 0;
}{}
    

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое наследование? Наследование — это механизм ООП, позволяющий одному классу (наследнику) унаследовать свойства и методы другого класса (родителя) для повторного использования и расширения. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Какая есть оптимизация в строках С++? Стандартный класс std::string в C++ имеет несколько механизмов оптимизации для повышения производительности и уменьшения расхода памяти. Рассмотрим основные из них. 🟠Small String Optimization (SSO) – Оптимизация малых строк Если строка маленькая (обычно до 15-23 байт, зависит от реализации), std::string не выделяет динамическую память, а хранит символы прямо внутри объекта std::string. Обычно std::string содержит: - Указатель на динамическую память - Размер строки - Вместимость (capacity) Но если строка короткая, память не выделяется в куче (heap), а данные хранятся прямо внутри объекта std::string.

    
        #include <iostream>
#include <string>

int main() {
    std::string small = "Hello"; // Использует SSO
    std::string large = "This is a very long string that will not fit SSO"; // Динамическая память

    std::cout << "Small string: " << small << "\n";
    std::cout << "Large string: " << large << "\n";
}{}
    

🟠Copy-on-Write (COW) – Оптимизация копирования (устарела) Раньше (до C++11) std::string использовал технику Copy-on-Write (COW), где несколько строк могли разделять одну и ту же память, пока одна из них не изменялась. Почему отказались? Не потокобезопасно (если один поток меняет строку, другой может получить неожиданные данные). В C++11 было добавлено std::move, которое делает копирование дешевле. SSO делает COW менее нужной.

    
        std::string a = "Hello";
std::string b = a; // Копия не создается, оба указывают на одну память
b[0] = 'X'; // Теперь создаётся отдельная копия{}
    

🟠Move Semantics – Семантика перемещения (C++11) Вместо дорогостоящего копирования std::string теперь можно перемещать с помощью std::move(), передавая владение ресурсом без копирования.

    
        #include <iostream>
#include <string>

int main() {
    std::string a = "Hello, world!";
    std::string b = std::move(a); // Перемещение, a становится пустой
    std::cout << "b: " << b << "\n"; // "Hello, world!"
}{}
    

🟠Reserve() – Избегание частых выделений памяти Если заранее известно, сколько символов потребуется, можно использовать .reserve(size), чтобы избежать многократных перевыделений памяти.

    
        std::string str;
str.reserve(100); // Сразу выделяет память на 100 символов
for (int i = 0; i < 100; i++) {
    str += 'a'; // Не перевыделяет память 100 раз
}{}
    

Ставь 👍 и забирай 📚 Базу знаний

🤔 Выбрасывание исключения из конструктора — это нормально? Да, выбрасывание исключения из конструктора допустимо, если объект не может быть корректно инициализирован. Однако необходимо учитывать возможные последствия, такие как утечка памяти. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Как вы будете реализовывать Singletone ? Это шаблон проектирования, который гарантирует, что класс имеет только один экземпляр, и предоставляет глобальную точку доступа к этому экземпляру. Существует несколько способов реализации Singleton, включая ленивую инициализацию, использование static и многопоточную безопасность. 🚩Основные методы реализации 🟠Ленивая инициализация (Lazy Initialization) При ленивой инициализации объект создается только при первом обращении к нему.

    
        class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }

    // Удаляем конструкторы копирования и присваивания
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() {} // Приватный конструктор
};{}
    

🟠Инициализация при запуске (Eager Initialization) При инициализации при запуске объект создается сразу при загрузке программы.

    
        class Singleton {
public:
    static Singleton& getInstance() {
        return instance;
    }

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

private:
    Singleton() {}
    static Singleton instance; // Статический экземпляр
};

Singleton Singleton::instance;{}
    

🟠Многопоточная безопасность (Thread-safe Singleton) Используя std::call_once и std::once_flag, можно обеспечить безопасность при доступе из нескольких потоков.

    
        #include <mutex>

class Singleton {
public:
    static Singleton& getInstance() {
        std::call_once(initInstanceFlag, &Singleton::initSingleton);
        return *instance;
    }

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

private:
    Singleton() {}
    static void initSingleton() {
        instance = new Singleton();
    }
    static Singleton* instance;
    static std::once_flag initInstanceFlag;
};

Singleton* Singleton::instance = nullptr;
std::once_flag Singleton::initInstanceFlag;{}
    

🚩Плюсы ➕Ленивая инициализация Экономит ресурсы, так как объект создается только при необходимости. ➕Инициализация при запуске Простая реализация, не требует дополнительных проверок, но объект создается даже если не используется. ➕Многопоточная безопасность Обеспечивает корректное создание объекта в многопоточной среде, но сложнее в реализации. Ставь 👍 и забирай 📚 Базу знаний

Запустите рекламу в телеграм-каналах с Яндекс Директом Перфоманс-реклама теперь в телеграм-каналах ⚡ Яндекс Директ знает, как привлечь целевую аудиторию 💰👌 Попробовать #реклама yandex.ru О рекламодателе