Как мы уже знаем из предыдущих уроков, выполнение программы в языке C++ происходит последовательно, строка за строкой, начиная с функции main(). Когда компилятор встречает вызов функции, то точка выполнения переходит к началу кода вызываемой функции. Откуда компилятор знает, что это нужно сделать?
При компиляции программы компилятор конвертирует каждый стейтмент программы в одну или несколько строк машинного кода. Каждой строке машинного кода присваивается собственный уникальный адрес. Так же и с функциями: когда компилятор встречает функцию, она конвертируется в машинный код и получает свой адрес.
Связывание — это процесс, который используется для конвертации идентификаторов (таких как имена переменных или функций) в адреса. Хотя связывание используется как для переменных, так и для функций, на этом уроке мы сосредоточимся только на функциях.
Раннее связывание
Большинство вызовов функций, которые встречает компилятор, являются прямыми вызовами функций. Прямой вызов функции — это стейтмент, который напрямую вызывает функцию. Например:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
#include <iostream> void printValue(int value) { std::cout << value; } int main() { printValue(7); // это прямой вызов функции return 0; } |
Прямые вызовы функций выполняются с помощью раннего связывания. Раннее связывание (или «статическая привязка») означает, что компилятор (или линкер) может напрямую связать имя идентификатора (например, имя функции или переменной) с машинным адресом. Помните, что все функции имеют свой уникальный адрес. Поэтому, когда компилятор (или линкер) встречает вызов функции, он заменяет его инструкцией машинного кода, которая сообщает процессору перейти к адресу функции.
Рассмотрим простую программу-калькулятор, в которой используется раннее связывание:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
#include <iostream> int add(int a, int b) { return a + b; } int subtract(int a, int b) { return a - b; } int multiply(int a, int b) { return a * b; } int main() { int a; std::cout << "Enter a number: "; std::cin >> a; int b; std::cout << "Enter another number: "; std::cin >> b; int op; do { std::cout << "Enter an operation (0 = add, 1 = subtract, 2 = multiply): "; std::cin >> op; } while (op < 0 || op > 2); int result = 0; switch (op) { // Вызываем конкретную функцию напрямую. Используется раннее связывание case 0: result = add(a, b); break; case 1: result = subtract(a, b); break; case 2: result = multiply(a, b); break; } std::cout << "The answer is: " << result << std::endl; return 0; } |
Поскольку add(a, b), subtract(a, b) и multiply(a, b) являются прямыми вызовами функций, то компилятор будет использовать раннее связывание. Он заменит вызов add(a, b) инструкцией, которая сообщит процессору перейти к адресу add(). То же самое выполнится и для subtract(a, b), и для multiply(a, b).
Позднее связывание
В некоторых программах невозможно знать наперёд, какая функция будет вызываться первой. В таком случае используется позднее связывание (или «динамическая привязка»). В языке C++ для выполнения позднего связывания используются указатели на функции. Вкратце, указатель на функцию — это тип указателя, который указывает на функцию вместо переменной. Функция, на которую указывает указатель, может быть вызвана через указатель и оператор вызова функции. Например, вызовем функцию add():
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#include <iostream> int add(int a, int b) { return a + b; } int main() { // Создаем указатель на функцию add int (*pFcn)(int, int) = add; std::cout << pFcn(4, 5) << std::endl; // вызов add(4 + 5) return 0; } |
Вызов функции через указатель на функцию также известен как непрямой (или «косвенный») вызов функции. Следующая программа-калькулятор идентична вышеприведенной программе, за исключением того, что вместо прямых вызовов функций используется указатель на функцию:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
#include <iostream> int add(int a, int b) { return a + b; } int subtract(int a, int b) { return a - b; } int multiply(int a, int b) { return a * b; } int main() { int a; std::cout << "Enter a number: "; std::cin >> a; int b; std::cout << "Enter another number: "; std::cin >> b; int op; do { std::cout << "Enter an operation (0 = add, 1 = subtract, 2 = multiply): "; std::cin >> op; } while (op < 0 || op > 2); // Создаем указатель на функцию с именем pFcn (согласен, синтаксис ужасен) int (*pFcn)(int, int) = nullptr; // Указываем pFcn указывать на функцию, которую выберет пользователь switch (op) { case 0: pFcn = add; break; case 1: pFcn = subtract; break; case 2: pFcn = multiply; break; } // Вызываем функцию, на которую указывает pFcn с параметрами a и b. // Используется позднее связывание std::cout << "The answer is: " << pFcn(a, b) << std::endl; return 0; } |
Здесь мы указываем pFcn указывать на функцию, которую выберет пользователь. Затем мы вызываем через указатель функцию, которую выбрал пользователь. Компилятор не может использовать раннее связывание для выполнения вызова функции pFcn(a, b), так как он не может наперёд определить, на какую функцию pFcn будет указывать!
Позднее связывание менее эффективное, так как присутствует «посредник» между процессором и функцией. С ранним связыванием процессор может перейти непосредственно к адресу функции. С поздним связыванием процессор должен прочитать адрес, хранящийся в указателе, и только затем перейти к этому адресу. Этот дополнительный шаг и замедляет весь процесс. Однако преимущество позднего связывания заключается в том, что оно более гибкое, нежели раннее связывание, так как не нужно решать, какую функцию следует вызывать до, собственно, запуска самой программы.
На следующем уроке мы рассмотрим, как позднее связывание используется для реализации виртуальных функций.
Оценить статью:
(188 оценок, среднее: 4,87 из 5)
Загрузка...