Хотя это и не относится в полной мере именно к объектно-ориентированному программированию, одной из очень важных особенностей языка C++, которую нельзя найти в С, служит использование inline-функций. inline-функция — это такая функция, чье тело подставляется в каждую точку вызова, вместо того, чтобы генерировать код вызова. Это подобно использованию параметризованных макросов в С. Имеются два способа создания inline-функций. Первый заключается в использовании модификатора inline. Например, для создания inline-функции f, возвращающей значение типа int и не имеющей параметров, достаточно объявить ее следующим образом:
inline int f();
Общая форма объявления inline-функций следующая:
inline объявление_функции;
Причина использования inline-функций заключается в их эффективности. Всякий раз, когда вызывается функция, необходимо выполнить серию инструкций для формирования вызова функции, вставки аргументов в стек и возврата значения из функции. В некоторых случаях для этого приходится использовать много тактов центрального процессора. При использовании inline-функций нет необходимости в таких дополнительных действиях, и скорость выполнения программы возрастает. Однако в тех случаях, когда размер inline-функций достаточно большой, общий объем программы также возрастает. Поэтому в качестве inline-функций обычно используются очень маленькие функции. Большие функции реализуются обычным способом. В качестве примера следующая программа использует ключевое слово inline для организации подстановки функций get_i() и put_i():
#include <iostream.h>
class C
{
int i;
public:
int get_i();
void put_i(int j);
};
inline int C::get_i()
{
return i;
}
inline void C::put_i(int j)
{
i = j;
}
int main()
{
C s;
s.put_i(10);
cout << s.get_i();
return 0;
}
Важно ясно понимать, что технически inline представляет запрос к компилятору сгенерировать подставляемый код; inline не является командой. В некоторых ситуациях компилятор не будет выполнять этот запрос. Например, некоторые компиляторы не подставляют функции, содержащие циклы, switch, операторы goto, функции, использующие исключения или имеющие в качестве параметра объект, содержащий деструктор, функции, возвращающие объекты, имеющие деструкторы.
Другим способом создания inline-функции служит включение кода функции внутри объявления класса. Всякая функция, определенная внутри объявления класса, является автоматически inline-функцией, если только это допустимо. В этом случае нет необходимости предварять объявление функции ключевым словом inline. Например, предыдущая программа может быть переписана следующим образом:
#include <iostream.h>
class C
{
int i;
public:
int get_i() { return i; }
void put_i(int j) { i = j; }
};
int main()
{
C s;
s.put_i(10);
cout << s.get_i();
return 0;
}
Обратим внимание, каким образом организован код. В профессионально написанном С++-коде короткие функции, наподобие проиллюстрированных в данном примере, обычно определяются внутри объявления класса.
Объекты могут быть переданы в функции тем же способом, что и переменные любого другого типа. Объекты передаются функциям с использованием стандартного механизма передачи по значению. Это означает, что создается копия объекта, которая и передается функции. Однако тот факт, что создается копия, означает по существу, что создается другой объект. В результате возникает вопрос, исполняется ли функция-конструктор объекта при создании копии и исполняется ли функция-деструктор, когда копия уничтожается. Ответ на эти два вопроса может очень удивить. Для начала рассмотрим пример:
#include <iostream.h>
class myclass
{
int i;
public:
myclass(int n);
~myclass();
void set_i(int n) { i=n; }
int get_i() { return i; }
};
myclass::myclass(int n)
{
i = n;
cout << "Constructing " << i << "\n";
}
myclass::-myclass()
{
cout << "Destroying " << i << "\n";
}
void f(myclass ob)
{
ob.set_i(2);
cout << “This is local i: “ << ob.get_i() << “\n”;
}
int main ()
{
myclass c1(1);
f(c1);
cout << "This is i in main: " << c1.get_i() << "\n";
return 0;
}
Эта программа выведет на экран следующий текст:
Constructing 1
This is local i: 2
Destroying 2
This is i in main: 1
Destroying 1
Обратим внимание, что имели место два вызова деструктора, в то время как конструктор вызывался только один раз. Выведенный текст иллюстрирует, что функция-конструктор не вызывается, когда копия объекта c1 (в программе main()) передается переменной ob (внутри функции f()). Причина, по которой конструктор не вызывался при создании копии объекта, может быть легко понята. Когда объект передается в функцию, нужно текущее состояние этого объекта. Если бы при создании копии вызывался конструктор, то осуществлялась бы инициализация объекта, которая бы изменила его состояние. Поэтому конструктор не может вызываться при создании копии объекта для передачи в функцию.
Хотя функция-конструктор не вызывалась при передаче объекта в функцию, необходимо вызывать деструктор при уничтожении копии. (Копия объекта уничтожается, как и любая локальная переменная, после окончания выполнения функции.) Надо иметь в виду, что копия объекта существует до тех пор, пока исполняется функция. Это означает, что копия может выполнять операции, которые потребуют вызова деструктора для уничтожения этой копии. Например, копия может резервировать память, которую необходимо освободить при ее уничтожении. По этой причине при уничтожении копии необходимо вызывать деструктор.
Суммируем сказанное. При создании копии объекта для передачи ее в функцию конструктор объекта не вызывается. Однако когда копия объекта внутри функции уничтожается, деструктор вызывается.
По умолчанию при создании копии объекта появляется его побитовая копия. Это означает, что новый объект служит точным дубликатом оригинала. Тот факт, что создается точная копия, может в некоторых случаях служить источником для беспокойства. Хотя для передачи объекта в функцию используется обычный механизм передачи по значению, который в теории защищает и изолирует вызываемый аргумент, остается возможность побочных эффектов, в результате которых может быть поврежден объект, используемый как аргумент. Например, если некоторый объект, используемый как аргумент, резервирует память и освобождает эту память при своем уничтожении, тогда его локальная копия внутри функции освободит ту же самую память при вызове деструктора. В результате исходный объект окажется поврежденным и по существу бесполезным. Как будет видно далее, можно предотвратить возникновение подобных проблем с помощью определения оператора копирования для собственного класса путем создания специального типа конструктора, который называется конструктором копирования.
