---
title: Функции и приведение типов
seo:
  title: Функции и приведение типов — C++ Developer
  description: Тема «Функции и приведение типов» для собеседования C++ Developer. Что такое перегрузка функции? Виды перегрузки. Что такое явное и неявное приведение типов в С++? Расскажите о функциях явного приведения типов в C++.
---

[Все темы C++ Developer](/c-developer)

## <strong>Что такое перегрузка функции? Виды перегрузки</strong> [#q-14bee738d69b81fc81dbe978c3ebe69b]

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

<strong>Виды перегрузки&#58;</strong>

{/* prettier-ignore */}
1. <strong>Перегрузка функций</strong>&#58;

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

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

1. <strong>Перегрузка операторов</strong>&#58;

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

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

:::note[Ссылки для изучения]

1. [Перегрузка функции в C++](https://metanit.com/cpp/tutorial/4.14.php)
   :::

---

## <strong>Что такое явное и неявное приведение типов в С++? Расскажите о функциях явного приведения типов в C++</strong> [#q-14bee738d69b8185b81fc73c653996b7]

<strong>Неявное приведение типов&#58;</strong>
Происходит автоматически, когда требуется преобразование одного типа в другой,
совместимый тип.

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

<strong>Явное приведение типов&#58;</strong>

Выполняется явно с использованием операторов приведения&#58;

{/* prettier-ignore */}
1. <code>static&#95;cast</code>

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

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

1. <code>dynamic&#95;cast</code>

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

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

1. <code>const&#95;cast</code>

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

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

1. <code>reinterpret&#95;cast</code>

    - Для ограниченного набора низкоуровневых преобразований, например между некоторыми типами указателей и целыми. Результат не разрешает произвольное разыменование&#58; нужно соблюдать требования времени жизни, выравнивания и доступа через допустимый тип.

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

:::note[Ссылки для изучения]

1. [Статическая типизация и преобразования типов](https://metanit.com/cpp/tutorial/2.4.php)
   :::

---

## <strong>Что такое ленивые вычисления в С++?</strong> [#q-14bee738d69b8176a368c58e54f16652]

Ленивые вычисления <code>&#40;lazy evaluation&#41;</code> в C++ — это стратегия, при которой вычисление значения откладывается до тех пор, пока оно не понадобится. Это может помочь оптимизировать производительность программы, избегая ненужных вычислений.

#### Пример&#58;

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

```cpp
#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;
}
```

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

:::note[Ссылки для изучения]

1. [Ленивые вычисления в C++](https://courses.igankevich.com/system-programming/tasks/spc-guards-and-operators-tasks/)
   :::

---

## <strong>Что делает ключевое слово</strong> <code>auto</code><strong>?</strong> <code>auto</code><strong>-определение</strong> <code>return</code><strong>-типа, аргументов функции?</strong> [#q-14bee738d69b81cbb93ffb16e1bcf344]

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

#### Примеры&#58;

{/* prettier-ignore */}
1. <strong>Определение типа переменной</strong>&#58;

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

1. <strong>Определение типа возвращаемого значения функции</strong>&#58;

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

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

1. <strong>Определение типа аргументов лямбда-функции</strong>&#58;

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

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

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

:::note[Ссылки для изучения]

1. [Оператор return и возвращение результата](https://metanit.com/cpp/tutorial/3.5.php)
   :::