Функции и приведение типов

Все темы C++ Developer

Что такое перегрузка функции? Виды перегрузки

Перегрузка функции — это возможность в C++ создавать несколько функций с одинаковым именем, но с различными параметрами (разный тип, количество или порядок параметров).

1. Перегрузка функций:

   • Функции имеют одинаковое имя, но различаются по типу, количеству или порядку параметров.

   void print(int i);
   void print(double d);
   void print(int i, double d);

2. Перегрузка операторов:

   • Переопределение поведения стандартных операторов (например, +, -, *, /) для пользовательских типов данных.

   class Complex {
   public:
       Complex operator+(const Complex& other);
   };

Что такое явное и неявное приведение типов в С++? Расскажите о функциях явного приведения типов в C++

Неявное приведение типов: Происходит автоматически, когда требуется преобразование одного типа в другой, совместимый тип.

int i = 3.14;  // double -> int, i = 3

Выполняется явно с использованием операторов приведения:

1. static_cast
   • Для обычных преобразований (например, между базовыми и производными классами).

   double d = 3.14;
   int i = static_cast<int>(d);

2. dynamic_cast
   • Для приведения указателей/ссылок на базовый класс к указателям/ссылкам на производный класс с проверкой времени выполнения.

   Base* b = new Derived();
   Derived* d = dynamic_cast<Derived*>(b);

3. const_cast
   • Для добавления или удаления const и volatile у подходящих указателей и ссылок. Изменение объекта, который изначально объявлен const, после снятия const приводит к неопределённому поведению.

   const int* p = &i;
   int* q = const_cast<int*>(p);

4. reinterpret_cast
   • Для ограниченного набора низкоуровневых преобразований, например между некоторыми типами указателей и целыми. Результат не разрешает произвольное разыменование: нужно соблюдать требования времени жизни, выравнивания и доступа через допустимый тип.

   int* p = reinterpret_cast<int*>(0x1234);

Что такое ленивые вычисления в С++?

Ленивые вычисления (lazy evaluation) в C++ — это стратегия, при которой вычисление значения откладывается до тех пор, пока оно не понадобится. Это может помочь оптимизировать производительность программы, избегая ненужных вычислений.

Пример:

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

#include <iostream>
#include <functional>

int expensiveComputation() {
    std::cout << "Performing expensive computation..." << std::endl;
    return 42;
}

int main() {
    std::function<int()> lazyValue = []() { return expensiveComputation(); };

    // Вычисление выполняется только при необходимости
    std::cout << "Result: " << lazyValue() << std::endl;

    return 0;
}

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

Что делает ключевое слово auto? auto-определение return-типа, аргументов функции?

auto позволяет компилятору автоматически выводить тип переменной на основе её инициализатора.

Примеры:

1. Определение типа переменной:

   auto x = 5;       // int
   auto y = 3.14;    // double
   auto str = "Hello"; // const char*

2. Определение типа возвращаемого значения функции:

   • Начиная с C++11 запись auto f() -> T явно указывает возвращаемый тип T; это не вывод типа. С C++14 запись auto f() { return expression; } позволяет вывести тип по return.

   auto add(int a, int b) -> int {
       return a + b;
   }

3. Определение типа аргументов лямбда-функции:

   • Лямбды могут использовать auto для автоматического определения типа аргументов.

   auto lambda = [](auto a, auto b) {
       return a + b;
   };

auto упрощает код и делает его более читаемым, автоматически выводя типы переменных и возвращаемые типы функций.