using namespace std;
class myclass {
int a, b;
public:
myclass(int i, int j) { a=i; b=j; }
friend int sum(myclass x); // Функция sum() - "друг" класса myclass.
};
// Обратите внимание на то, что функция sum() не является членом ни одного класса int sum(myclass х)
{
/* Поскольку функция sum() — "друг" класса myclass, она имеет право на прямой доступ к его членам данных а и b. */
return x.a + x.b;
}
int main ()
{
myclass n (3, 4);
cout << sum(n);
return 0;
}
В этом примере функция sum() не является членом класса myclass. Тем не менее она имеет полный доступ к private-членам класса myclass. В частности, она может непосредственно использовать значения х.а и х.b. Обратите также внимание на то, что функция sum() вызывается обычным образом, т.е. без привязки к объекту (и без использования оператора "точка"). Поскольку она не функция-член, то при вызове ее не нужно квалифицировать с указанием имени объекта. (Точнее, при ее вызове нельзя задавать имя объекта.) Обычно функции-"другу" в качестве параметра передается один или несколько объектов класса, для которого она является "другом", как в случае функции sum().
Несмотря на то что в данном примере мы не извлекаем никакой пользы из объявления
функции sum() "другом", а не членом класса myclass, существуют определенные обстоятельства, при которых статус функции-"друга" имеет большое значение. Во-первых,
функции-"друзья" могут быть полезны для перегрузки операторов определенных типов. Во- вторых, функции-"друзья" упрощают создание некоторых функций ввода-вывода. Об этом речь впереди.
Третья причина использования функций-"друзей" состоит в том, что в некоторых случаях два (или больше) класса могут содержать члены, которые находятся во взаимной связи с другими частями программы. Например, у нас есть два различных класса, которые при возникновении определенных событий отображают на экране "всплывающие"
сообщения. Другие части программы, которые предназначены для вывода данных на экран,
должны знать, является ли "всплывающее" сообщение активным, чтобы случайно не перезаписать его. В каждом классе можно создать функцию-член, возвращающую значение,
по которому можно судить о том, активно сообщение или нет; однако проверка этого условия потребует дополнительных затрат (т.е. двух вызовов функций вместо одного). Если статус "всплывающего" сообщения необходимо проверять часто, эти дополнительные затраты могут оказаться попросту неприемлемыми. Однако с помощью функции,
"дружественной" для обоих классов, можно напрямую проверять статус каждого объекта,
вызывая только одну функцию, которая будет иметь доступ к обоим классам. В подобных ситуациях функция-"друг" позволяет написать более эффективный код. Эта идея иллюстрируется на примере следующей программы.
// Использование функции-"друга".
#include
using namespace std;
const int IDLE=0;
const int INUSE=1;
class С2; // опережающее объявление class C1 {
int status; // IDLE если сообщение неактивно, INUSE если сообщение выведено на экран.
// ...
public:
void set_status(int state);
friend int idle(C1 a, C2 b);
};
class C2 {
int status; // IDLE если сообщение неактивно, INUSE если сообщение выведено на экран.
// ...
public:
void set_status(int state);
friend int idle(C1 a, C2 b);
};
void C1::set_status(int state)
{
status = state;
}
void C2::set_status(int state)
{
status = state;
}
// Функция idle() - "друг" для классов C1 и C2.
int idle(C1 a, C2 b)
{
if(a.status || b.status) return 0;
else return 1;
}
int main()
{
C1 x;
C2 y;
x.set_status(IDLE);
у.set_status(IDLE);
if(idle(x, y)) cout << "Экран свободен.\n";
else cout << "Отображается сообщение.\n";
x.set_status(INUSE);
if(idle(x, y)) cout << "Экран свободен.\n";
else cout << "Отображается сообщение.\n";
return 0;
}
При выполнении программа генерирует такие результаты.
Экран свободен.
Отображается сообщение.
Поскольку функция idle() является "другом" как для класса С1, так и для класса С2, она имеет доступ к закрытому члену status, определенному в обоих классах. Таким образом,
состояние объекта каждого класса одновременно можно проверить всего одним обращением к функции idle().
Опережающее объявление предназначено для объявления имени классового типа доопределения самого класса.Обратите внимание на то, что в этой программе используется
опережающее объявление(также именуемое
опережающей ссылкой) для класса
С2. Его необходимость обусловлена тем, что объявление функции
idle() в классе
С1 использует ссылку на класс
С2 до его объявления. Чтобы
создать опережающее объявление для класса, достаточно использовать формат, представленный в этой программе.
"Друг" одного класса может быть членом другого класса. Перепишем предыдущую программу так, чтобы функция
idle() стала членом класса
С1. Обратите внимание на использование оператора разрешения области видимости (или оператора разрешения контекста) при объявлении функции
idle() в качестве
"друга" класса
С2.
/* Функция может быть членом одного класса и одновременно "другом" другого.
*/
#include
using namespace std;
const int IDLE=0;
const int INUSE=1;
class C2; // опережающее объявление class C1 {
int status; // IDLE, если сообщение неактивно, INUSE, если сообщение выведено на экран.
// ...
public:
void set_status(int state);
int idle(C2 b); // теперь это член класса C1
};
class C2 {
int status; // IDLE, если сообщение неактивно, INUSE, если сообщение выведено на экран.
// . . .
public:
void set_status(int state);
friend int C1::idle(C2 b); // функция-"друг"
};
void C1::set_status(int state)
{
status = state;
}
void C2::set_status(int state)
{
status = state;
}
// Функция idle() -- член класса С1 и "друг" класса С2.
int C1::idle(С2 b)
{
if(status || b.status) return 0;
else return 1;
}
int main()
{
C1 x;
C2 y;
x.set_status(IDLE);
y.set_status(IDLE);
if(x.idle(y)) cout << "Экран свободен.\n";
else cout << "Отображается сообщение.\n";
x.set_status(INUSE);
if(x.idle(y)) cout << "Экран свободен.\n";
else cout << "Отображается сообщение.\n";
return 0;
}
Поскольку функция idle() является членом класса C1, она имеет прямой доступ к переменной status объектов типа С1. Следовательно, в качестве параметра необходимо передавать функции idle() только объекты типа С2.
Перегрузка конструкторов
Несмотря на выполнение конструкторами уникальных действий, они не сильно отличаются от функций других типов и также могут подвергаться перегрузке. Чтобы перегрузить конструктор класса, достаточно объявить его во всех нужных форматах и определить каждое действие, связанное с соответствующим форматом. Например, в следующей программе объявляется класс timer, который действует как вычитающий таймер.
При создании объекта типа timer таймеру присваивается некоторое начальное значение времени. При вызове функции run() таймер выполняет счет в обратном порядке до нуля, а затем подает звуковой сигнал. В этом примере конструктор перегружается трижды,
предоставляя тем самым возможность задавать время как в секундах (причем либо числом,
либо строкой), так и в минутах и секундах (с помощью двух целочисленных значений). В
этой программе используется стандартная библиотечная функция clock(), которая возвращает количество сигналов, принятых от системных часов с момента начала выполнения программы. Вот как выглядит прототип этой функции:
clock_t clock();
Тип clock_t представляет собой разновидность длинного целочисленного типа.
Операция деления значения, возвращаемого функцией
clock(), на значение
CLOCKS_PER_SEC позволяет преобразовать результат в секунды. Как прототип для функции clock(), так и определение константы CLOCKS_PER_SEC принадлежат заголовку
.
// Использование перегруженных конструкторов.
#include
#include
#include
using namespace std;
class timer{
int seconds;
public:
// секунды, задаваемые в виде строки timer(char *t) { seconds = atoi (t); }
// секунды, задаваемые в виде целого числа timer(int t) { seconds = t; }
// время, задаваемое в минутах и секундах
timer(int min, int sec) { seconds = min*60 + sec; }
void run();
};
void timer::run()
{
clock_t t1;
t1 = clock();
while( (clock()/CLOCKS_PER_SEC - t1/CLOCKS_PER_SEC) cout << "\a"; // звуковой сигнал
}
int main()
{
timer a (10), b("20"), c(1, 10);
a.run(); // отсчет 10 секунд b.run(); // отсчет 20 секунд c.run(); // отсчет 1 минуты и 10 секунд return 0;
}
При создании в функции main() объектов а, b и с класса timer им присваиваются начальные значения тремя различными способами, поддерживаемыми перегруженными функциями конструкторов. В каждом случае вызывается конструктор, который соответствует заданному списку параметров и потому надлежащим образом
инициализирует "свой" объект.
На примере предыдущей программы вы, возможно, не оценили значимость перегрузки функций конструктора, поскольку здесь можно было обойтись единым способом задания временного интервала. Но если бы вы создавали библиотеку классов на заказ, то вам стоило бы предусмотреть набор конструкторов, охватывающий самый широкий спектр различных форматов инициализации, тем самым обеспечив других программистов наиболее подходящими для их программ форматами. Кроме того, как будет показано ниже, в C++
существует атрибут, который делает перегруженные конструкторы особенно ценным средством инициализации объектов.
Динамическая инициализация
В C++ как локальные, так и глобальные переменные можно инициализировать во время выполнения программы. Этот процесс иногда называют динамической инициализацией. До сих пор в большинстве инструкций инициализации, представленных в этой книге,
использовались константы. Однако переменную можно также инициализировать во время выполнения программы, используя любое С++-выражение, действительное на момент объявления этой переменной. Это означает, что переменную можно инициализировать с помощью других переменных и/или вызовов функций при условии, что в момент выполнения инструкции объявления общее выражение инициализации имеет действительное значение. Например, следующие варианты инициализации переменных абсолютно допустимы в C++,
int n = strlen(str);
double arc = sin(theta);
float d = 1.02 * count / deltax;
Применение динамической инициализации к конструкторам
Подобно простым переменным, объекты можно инициализировать динамически при их создании. Это средство позволяет создавать объект нужного типа с использованием информации, которая становится известной только во время выполнения программы. Чтобы показать, как работает механизм динамической инициализации, модифицируем программу реализации таймера, приведенную в предыдущем разделе.
Вспомните, что в первом примере программы таймера мы не получили большого преимущества от перегрузки конструктора timer(), поскольку все объекты этого типа инициализировались с помощью констант, известных во время компиляции программы. Но в случаях, когда объект необходимо инициализировать во время выполнения программы,
можно получить существенный выигрыш от наличия множества разных форматов инициализации. Это позволяет программисту выбрать из существующих конструкторов тот,
который наиболее точно соответствуют текущему формату данных.
Например, в следующей версии программы таймера для создания двух объектов b и с
используется динамическая инициализация.
// Демонстрация динамической инициализации.
#include
#include
#include
using namespace std;
class timer{
int seconds;
public:
// секунды, задаваемые в виде строки timer(char *t) { seconds = atoi(t); }
// секунды, задаваемые в виде целого числа timer(int t) { seconds = t; }
// время, задаваемое в минутах и секундах timer(int min, int sec) { seconds = min*60 + sec; }
void run();
};
void timer::run()
{
clock_t t1;
t1 = clock();
while((clock()/CLOCKS_PER_SEC - t1/CLOCKS_PER_SEC)
cout << "\a"; // звуковой сигнал
}
int main()
{
timer a(10);
a.run();
cout << "Введите количество секунд: ";
char str[80];
cin >> str;
timer b(str); // инициализация в динамике b.run();
cout << "Введите минуты и секунды: ";
int min, sec;
cin >> min >> sec;
timer с(min, sec); // инициализация в динамике c.run();
return 0;
}
Как видите, объект a создается с использованием целочисленной константы. Однако основой для создания объектов b и c служит информация, вводимая пользователем.
Поскольку для объекта b пользователь вводит строку, имеет смысл перегрузить конструктор
timer() для приема строк. Объект c также создается во время выполнения программы с использованием данных, вводимых пользователем. Поскольку в этом случае время вводится
в виде минут и секунд, для построения объекта c логично использовать формат конструктора, принимающего два аргумента. Трудно не согласиться с тем, что наличие множества форматов инициализации избавляет программиста от выполнения дополнительных преобразований при инициализации объектов.
Механизм перегрузки конструкторов способствует понижению уровня сложности программ, позволяя создавать объекты наиболее естественным для их применения образом.
Поскольку существует три наиболее распространенных способа передачи объекту значений временных интервалов, имеет смысл позаботиться о том, чтобы конструктор timer() был перегружен для реализации каждого из этих способов. При этом перегрузка конструктора
timer() для приема значения, выраженного в днях или наносекундах, вряд ли себя оправдает.
Загромождение кода конструкторами для обработки редко возникающих ситуаций оказывает, как правило, дестабилизирующее влияние на программу.
Узелок на память. Разрабатывая перегруженные конструкторы, необходимо
определиться в том, какие ситуации важно предусмотреть, а какие можно и не
учитывать.
Присваивание объектов
Если два объекта имеют одинаковый тип (т.е. оба они — объекты одного класса), то один объект можно присвоить другому. Для присваивания недостаточно, чтобы два класса были физически подобны; имена классов, объекты которых участвуют в операции присваивания, должны совпадать. Если один объект присваивается другому, то по умолчанию данные первого объекта поразрядно копируются во второй. Присваивание объектов демонстрируется в следующей программе.
// Демонстрация присваивания объектов.
#include
using namespace std;
class myclass {
int a, b;
public:
void setab(int i, int j) { a = i, b = j; }
void showab();
};
void myclass::showab()
{
cout << "а равно " << a << '\n';
cout << "b равно " << b << '\n';
}
int main()
{
myclass ob1, ob2;
ob1.setab(10, 20);
ob2.setab(0, 0);
cout << "Объект ob1 до присваивания: \n";
ob1.showab();
cout << "Объект ob2 до присваивания: \n";
ob2.showab();
cout << ' \n';
ob2 = ob1; // Присваиваем объект ob1 объекту ob2.
cout << "Объект ob1 после присваивания: \n";
ob1.showab();
cout << "Объект ob2 после присваивания: \n";
ob2.showab();
return 0;
}
При выполнении программа генерирует такие результаты.
Объект ob1 до присваивания:
а равно 10
b равно 20
Объект ob2 до присваивания:
а равно 0
b равно 0
Объект ob1 после присваивания:
а равно 10
b равно 20
Объект ob2 после присваивания:
а равно 10
b равно 20
По умолчанию все данные из одного объекта присваиваются другому путем создания поразрядной копии. (Другими словами, создается точный дубликат объекта.) Но, как будет показано ниже, оператор присваивания можно перегрузить, определив собственные операции присваивания.
Узелок на память. Присваивание одного объекта другому просто делает их данные
идентичными, но эти два объекта остаются совершенно независимыми. Следовательно,
последующая модификация данных одного объекта не оказывает никакого влияния на
данные другого.
Передача объектов функциям
Объект можно передать функции точно так же, как значение любого другого типа данных. Объекты передаются функциям путем использования обычного С++-соглашения о передаче параметров по значению. Таким образом, функции передается не сам объект, а его копия. Следовательно, изменения, внесенные в объект при выполнении функции, не оказывают никакого влияния на объект, используемый в качестве аргумента для функции.
Этот механизм демонстрируется в следующей программе.
#include
using namespace std;
class OBJ {
int i;
public:
void set_i(int x) { i = x; }
void out_i() { cout << i << " "; }
};
void f(OBJ x)
{
x.out_i(); // Выводит число.
х.set_i(100); // Устанавливает только локальную копию.
x.out_i(); // Выводит число 100.
}
int main()
{
OBJ о;
о.set_i(10);
f(о);
o.out_i();
//
По-прежнему выводит число
10, значение переменной i не изменилось.
return 0;
}
Вот как выглядят результаты выполнения этой программы.
10 100 10
Как подтверждают эти результаты, модификация объекта x в функции f() не влияет на объект o в функции main().
Конструкторы, деструкторы и передача объектов
Несмотря на то что передача функциям несложных объектов в качестве аргументов —
довольно простая процедура, при этом могут происходить непредвиденные события,
имеющие отношение к конструкторам и деструкторам. Чтобы разобраться в этом,
рассмотрим следующую программу.
// Конструкторы, деструкторы и передача объектов.
#include
using namespace std;
class myclass {
int val;
public:
myclass(int i) { val = i; cout << "Создание\n"; }
myclass() { cout << "Разрушение\n"; }
int getval() { return val; }
};
void display(myclass ob)
{
cout << ob.getval() << '\n';
}
int main()
{
myclass a(10);
display(a);
return 0;
}
При выполнении эта программа выводит следующие неожиданные результаты.
Создание
10
Разрушение
Разрушение
Как видите, здесь выполняется одно обращение к функции конструктора (при создании объекта
a), но почему-то два обращения к функции деструктора. Давайте разбираться, в чем тут дело.
При передаче объекта функции создается его копия (и эта копия становится параметром в функции). Создание копии означает "рождение" нового объекта. Когда выполнение функции завершается, копия аргумента (т.е. параметр) разрушается. Здесь возникает сразу два вопроса. Во-первых, вызывается ли конструктор объекта при создании копии? Во- вторых, вызывается ли деструктор объекта при разрушении копии? Ответы могут удивить вас.
Когда при
вызове функции создается копия аргумента, обычный конструктор не вызывается. Вместо этого вызывается
конструктор копии объекта. Конструктор копии определяет, как должна быть создана копия объекта. (Как создать конструктор копии, будет показано ниже в этой главе.) Но если в классе явно не определен конструктор копии, C++
предоставляет его по умолчанию. Конструктор копии по умолчанию создает побитовую (т.е.
идентичную) копию объекта. Поскольку обычный конструктор используется для инициализации некоторых аспектов объекта, он не должен вызываться для создания копии уже существующего объекта. Такой вызов изменил бы его содержимое. При передаче объекта функции имеет смысл использовать текущее состояние объекта, а не его начальное состояние.
Но когда функция завершается и разрушается копия объекта, используемая в качестве аргумента, вызывается деструктор этого объекта. Необходимость вызова деструктора связана с выходом объекта из области видимости. Именно поэтому предыдущая программа имела два обращения к деструктору. Первое произошло при выходе из области видимости параметра функции
display(), а второе— при разрушении объекта
a в функции main() по завершении программы.
Итак, когда объект передается функции в качестве аргумента, обычный конструктор не
вызывается. Вместо него вызывается конструктор копии, который по умолчанию создает побитовую (идентичную) копию этого объекта. Но когда эта копия разрушается (обычно при выходе за пределы области видимости по завершении функции), обязательно вызывается деструктор.
Потенциальные проблемы при передаче параметров
Несмотря на то что объекты передаются функциям "по значению", т.е. посредством обычного С++-механизма передачи параметров, который теоретически защищает аргумент и изолирует его от принимаемого параметра, здесь все-таки возможен побочный эффект или даже угроза для "жизни" объекта, используемого в качестве аргумента. Например, если объект, используемый как аргумент, требует динамического выделения памяти и освобождает эту память при разрушении, его локальная копия при вызове деструктора освободит ту же самую область памяти, которая была выделена оригинальному объекту. И
этот факт становится уже целой проблемой, поскольку оригинальный объект все еще использует эту (уже освобожденную) область памяти. Описанная ситуация делает исходный объект "ущербным" и, по сути, непригодным для использования. Рассмотрим следующую простую программу.
// Демонстрация проблемы, возможной при передаче объектов функциям.
#include
#include
using namespace std;
class myclass {
int *p;
public:
myclass(int i);
myclass();
int getval() { return *p; }
};
myclass::myclass(int i)
{
cout << "Выделение памяти, адресуемой указателем p.\n";
р = new int;
*p = i;
}
myclass::myclass()
{
cout <<"Освобождение памяти, адресуемой указателем p.\n";
delete p;
}
// При выполнении этой функции и возникает проблема.
void display(myclass ob)
{
cout << ob.getval() << '\n';
}
int main()
{
myclass a(10);
display(a);
return 0;
}
Вот как выглядят результаты выполнения этой программы.
Выделение памяти, адресуемой указателем р.
10
Освобождение памяти, адресуемой указателем р.
Освобождение памяти, адресуемой указателем р.
Эта программа содержит принципиальную ошибку. И вот почему: при создании в функции main() объекта a выделяется область памяти, адрес которой присваивается указателю а.р . При передаче функции display() объект a копируется в параметр ob. Это означает, что оба объекта (a и ob) будут иметь одинаковое значение для указателя р.
Другими словами, в обоих объектах (в оригинале и его копии) член данных p будет указывать на одну и ту же динамически выделенную область памяти. По завершении функции display() объект ob разрушается, и его разрушение сопровождается вызовом деструктора. Деструктор освобождает область памяти, адресуемую указателем ob.р. Но ведь эта (уже освобожденная) область памяти — та же самая область, на которую все еще указывает член данных (исходного объекта) a.p! Налицо серьезная ошибка.
В действительности дела обстоят еще хуже. По завершении программы разрушается объект a, и динамически выделенная (еще при его создании) память освобождается вторично. Дело в том, что освобождение одной и той же области динамически выделенной памяти во второй раз считается неопределенной операцией, которая, как правило (в зависимости от того, как реализована система динамического распределения памяти),
вызывает неисправимую ошибку.
Возможно, читатель уже догадался, что один из путей решения проблемы, связанной с разрушением (еще нужных) данных деструктором объекта, являющегося параметром функции, состоит не в передаче самого объекта, а в передаче указателя на него или ссылки.
В этом случае копия объекта не создается; следовательно, по завершении функции деструктор не вызывается. Вот как выглядит, например, один из способов исправления предыдущей программы.
// Одно из решений проблемы передачи объектов.
#include
#include
using namespace std;
class myclass {
int *p;
public:
myclass(int i);
myclass();
int getval() { return *p; }
};
myclass::myclass(int i)
{
cout << "Выделение памяти, адресуемой указателем p.\n";
р = new int;
*p = i;
}
myclass::myclass()
{
cout <<"Освобождение памяти, адресуемой указателем p.\n";
delete p;
}
/* Эта функция HE создает проблем. Поскольку объект ob теперь передается по ссылке, копия аргумента не создается, а
следовательно, объект не выходит из области видимости по завершении функции display().
*/
void display(myclass &ob)
{
cout << ob.getval() << '\n';
}
int main()
{
myclass a(10);
display(a);
return 0;
}
Результаты выполнения этой версии программы выглядят гораздо лучше предыдущих.
Выделение памяти, адресуемой указателем р.
10
Освобождение памяти, адресуемой указателем р.
Как видите, здесь деструктор вызывается только один раз, поскольку при передаче по ссылке аргумента функции
display() копия объекта не создается.
Передача объекта по ссылке — прекрасное решение описанной проблемы, но только в случаях,
когда ситуация позволяет принять его, что бывает далеко не всегда. К счастью, есть более общее решение: можно создать собственную версию конструктора копии. Это позволит точно определить, как именно следует создавать копию объекта и тем самым избежать описанных выше проблем. Но прежде чем мы займемся конструктором копии,
имеет смысл рассмотреть еще одну ситуацию, в обработке которой мы также можем выиграть от создания
конструктора копии.
Возвращение объектов функциямиЕсли объекты можно передавать функциям, то
"с таким же успехом" функции могут возвращать объекты. Чтобы функция могла вернуть объект, во-первых, необходимо объявить в качестве типа возвращаемого ею значения тип соответствующего класса. Во-вторых,
нужно обеспечить возврат объекта этого типа с помощью обычной инструкции
return.
Рассмотрим пример функции, которая возвращает объект.
// Использование функции, которая возвращает объект.
#include
#include
using namespace std;
class sample {
char s[80];
public:
void show() { cout << s << "\n"; }
void set(char *str) { strcpy(s, str); }
};
// Эта функция возвращает объект типа sample.
sample input()
{
char instr[80];
sample str;
cout << "Введите строку: ";
cin >> instr;
str.set(instr);
return str;
}
int main()
{
sample ob;
// Присваиваем объект, возвращаемый
// функцией input(), объекту ob.
ob = input();
ob.show();
return 0;
}
В этом примере функция input() создает локальный объект str класса sample, а затем считывает строку с клавиатуры. Эта строка копируется в строку str.s, после чего объект str
возвращается функцией input() и присваивается объекту ob в функции main().
Потенциальная проблема при возвращении объектов функциями
Относительно возвращения объектов функциями важно понимать следующее. Если функция возвращает объект класса, она автоматически создает временный объект, который хранит возвращаемое значение. Именно этот объект реально и возвращается функцией.
После возврата значения объект разрушается. Разрушение временного объекта в некоторых ситуациях может вызвать непредвиденные побочные эффекты. Например, если объект,
возвращаемый функцией, имеет деструктор, который освобождает динамически выделяемую память, эта память будет освобождена даже в том случае, если объект,
получающий возвращаемое функцией значение, все еще ее использует. Рассмотрим следующую некорректную версию предыдущей программы.
// Ошибка, генерируемая при возвращении объекта функцией.
#include
#include
#include
using namespace std;
class sample {
char *s;
public:
sample() { s = 0; }
sample() {
if(s) delete [] s;
cout << "Освобождение s-памяти.\n";
}
void show() { cout << s << "\n"; }
void set(char *str);
};
// Загрузка строки.
void sample::set(char *str)
{
s = new char[strlen(str)+1];
strcpy(s, str);
}
// Эта функция возвращает объект типа sample.
sample input()
{
char instr[80];
sample str;
cout << "Введите строку: ";
cin >> instr;
str.set(instr);
return str;
}
int main()
{
sample ob;
// Присваиваем объект, возвращаемый
// функцией input(), объекту ob.
ob = input(); // Эта инструкция генерирует ошибку!!!!
ob.show(); // Отображение "мусора".
return 0;
}
Результаты выполнения этой программы выглядят таким образом.
Введите строку: Привет
Освобождение s-памяти.
Освобождение s-памяти.
Здесь мусор
Освобождение s-памяти.
Обратите внимание на то, что деструктор класса sample вызывается три раза! В первый раз он вызывается при выходе локального объекта str из области видимости в момент возвращения из функции input(). Второй вызов деструктора sample() происходит тогда,
когда разрушается временный объект, возвращаемый функцией input(). Когда функция возвращает объект, автоматически генерируется невидимый (для вас) временный объект,
который хранит возвращаемое значение. В данном случае этот объект просто представляет собой побитовую копию объекта str, который является значением, возвращаемым из функции. Следовательно, после возвращения из функции выполняется деструктор временного объекта. Поскольку область памяти, выделенная для хранения строки, вводимой пользователем, уже была освобождена (причем дважды!), при вызове функции show() на экран выведется "мусор". (Вы можете не увидеть вывод на экран "мусора". Это зависит от того, как ваш компилятор реализует динамическое выделение памяти. Однако ошибка все равно здесь присутствует.) Наконец, по завершении программы вызывается деструктор объекта ob (в функции main()). Ситуация здесь осложняется тем, что при первом вызове деструктора освобождается память, выделенная для хранения строки, получаемой функцией
input(). Таким образом, само по себе плохо не только то, что остальные два обращения к деструктору класса
sample попытаются освободить уже освобожденную область динамически выделяемой памяти, но они также могут разрушить систему динамического распределения памяти.
Здесь важно понимать, что при возврате объекта из функции для временного объекта,
хранящего возвращаемое значение, будет вызван его деструктор. Поэтому следует избегать возврата объектов в ситуациях, когда это может иметь пагубные последствия. Для решения этой проблемы вместо возврата объекта из функции используется возврат указателя или ссылки на объект. Но это не всегда осуществимо. Еще один способ решения этой проблемы включает использование конструктора копии, которому посвящен следующий раздел.
Создание и использование конструктора копииОдним из самых важных форматов перегруженного конструктора является конструктор копии. Как было показано в предыдущих примерах, при передаче объекта функции или возврате объекта из функции могут возникать проблемы. В этом разделе вы узнаете, что один из способов избежать этих проблем состоит в определении
конструктора копии,
который представляет собой специальный тип перегруженного конструктора.
Для начала еще раз сформулируем проблемы, для решения которых мы хотим определить конструктор копии. При передаче объекта функции создается побитовая (т.е.
точная) копия этого объекта, которая передается параметру этой функции. Однако возможны ситуации, когда такая идентичная копия нежелательна. Например, если оригинальный объект содержит указатель на выделяемую динамически память, то и указатель, принадлежащий копии, также будет ссылаться на ту же область памяти.
Следовательно, если копия внесет изменения в содержимое этой области памяти, эти изменения коснутся также оригинального объекта! Более того, при завершении функции копия будет разрушена (с вызовом деструктора). Это может нежелательным образом сказаться на исходном объекте.
Аналогичная ситуация возникает при возврате объекта из функции. Компилятор генерирует временный объект, который будет хранить копию значения, возвращаемого функцией. (Это делается автоматически, и без нашего на то согласия.) Этот временный объект выходит за пределы области видимости сразу же, как только инициатору вызова этой функции будет возвращено "обещанное" значение, после чего незамедлительно вызывается деструктор временного объекта. Но если этот деструктор разрушит что-либо нужное для выполняемого далее кода, последствия будут печальны.
Конструктор копии позволяет управлять действиями, составляющими процесссоздания копии объекта.В сердцевине рассматриваемых проблем лежит создание побитовой копии объекта.
Чтобы предотвратить их возникновение, необходимо точно определить, что должно происходить, когда создается копия объекта, и тем самым избежать нежелательных побочных эффектов. Этого можно добиться путем создания конструктора копии.
Прежде чем подробнее знакомиться с использованием конструктора копии, важно понимать, что в C++ определено два отдельных вида ситуаций, в которых значение одного объекта передается другому. Первой такой ситуацией является присваивание, а второй —
инициализация. Инициализация может выполняться тремя способами, т.е. в случаях, когда:
■ один объект явно инициализирует другой объект, как, например, в объявлении;
■ копия объекта передается параметру функции;
■ генерируется временный объект (чаще всего в качестве значения, возвращаемого функцией).
Конструктор копии применяется только к инициализациям. Он не применяется к присваиваниям.
Узелок на память. Конструкторы копии не оказывают никакого влияния на операции
присваивания.
Конструктор копии вызывается в случае, когда один объект инициализирует другой.
Вот как выглядит самый распространенный формат конструктора копии.
имя_класса (const имя_класса &obj) {
// тело конструктора
}
Здесь элемент obj означает ссылку на объект, которая используется для инициализации другого объекта. Например, предположим, у нас есть класс myclass и объект y типа myclass,
тогда при выполнении следующих инструкций будет вызван конструктор копии класса
myclass.
myclass х = у; // Объект у явно инициализирует объект x х.func1(у); // Объект у передается в качестве аргумента.
у = func2(); // Объект у принимает объект, возвращаемый функцией.
В первых двух случаях конструктору копии будет передана ссылка на объект у, а в третьем — ссылка на объект, возвращаемый функцией func2().
Чтобы глубже понять назначение конструкторов копии, рассмотрим подробнее их роль в каждой из этих трех ситуаций.
Конструкторы копии и параметры функции
При передаче объекта функции в качестве аргумента создается копия этого объекта.
Если в классе определен конструктор копии, то именно он и вызывается для создания копии. Рассмотрим программу, в которой используется конструктор копии для надлежащей обработки объектов типа myclass при их передаче функции в качестве аргументов. (Ниже приводится корректная версия некорректной программы, представленной выше в этой главе.)
// Использование конструктора копии для
// определения параметра.
#include
#include
using namespace std;
class myclass {
int *p;
public:
myclass(int i); // обычный конструктор myclass(const myclass &ob); // конструктор копии
myclass();
int getval() { return *p; }
};
// Конструктор копии.
myclass::myclass(const myclass &obj)
{
p = new int;
*p = *obj.p; // значение копии cout << "Вызван конструктор копии.\n";
}
// Обычный конструктор.
myclass::myclass(int i)
{
cout << "Выделение памяти, адресуемой указателем p.\n";
р = new int;
*p = i;
}
myclass::myclass()
{
cout <<"Освобождение памяти, адресуемой указателем p.\n";
delete p;
}
// Эта функция принимает один объект-параметр.
void display(myclass ob)
{
cout << ob.getval() << '\n';
}
int main()
{
myclass a(10);
display(a);
return 0;
}
Эта программа генерирует такие результаты.
Выделение памяти, адресуемой указателем р.
Вызван конструктор копии.
10
Освобождение памяти, адресуемой указателем р.
Освобождение памяти, адресуемой указателем р.
При выполнении этой программы здесь происходит следующее: когда в функции
main()создается объект
а,
"стараниями" обычного конструктора выделяется память, и адрес этой области памяти присваивается указателю
а.р. Затем объект
а передается функции
display(),
а именно— ее параметру
ob. В этом случае вызывается конструктор копии, который создает копию объекта
а. Конструктор копии выделяет память для этой копии, а значение указателя на выделенную область памяти присваивает члену
р объекта-копии. Затем значение,
адресуемое указателем
р исходного объекта, записывается в область памяти, адрес которой хранится в указателе
р объекта-копии. Таким образом, области памяти, адресуемые указателями
а.р и
ob.р, раздельны и независимы одна от другой, но хранимые в них значения (на которые указывают
а.р и
ob.р) одинаковы. Если бы конструктор копии не был определен, то в результате создания по умолчанию побитовой копии члены
а.р и
ob.руказывали бы на одну и ту же область памяти.
По завершении функции
display() объект
ob выходит из области видимости. Этот выход сопровождается вызовом его деструктора, который освобождает область памяти,
адресуемую указателем
ob.р. Наконец, по завершении функции
main() выходит из области видимости объект
а, что также сопровождается вызовом его деструктора и соответствующим освобождением области памяти, адресуемой указателем
а.р. Как видите,
использование конструктора копии устраняет деструктивные побочные эффекты, связанные с передачей объекта функции.
Использование конструкторов копии при инициализации объектовКонструктор копии также вызывается в случае, когда один объект используется для инициализации другого.
Рассмотрим следующую простую программу.
// Вызов конструктора копии для инициализации объекта.
#include
#include
using namespace std;
class myclass {
int *p;
public:
myclass(int i); // обычный конструктор myclass(const myclass &ob); // конструктор копии
myclass();
int getval() { return *p; }
};
// Конструктор копии.
myclass::myclass(const myclass &ob)
{
p = new int;
*p = *ob.p; // значение копии cout << "Выделение p-памяти конструктором копии.\n";
}
// Обычный конструктор.
myclass::myclass(int i)
{
cout << "Выделение p-памяти обычным конструктором.\n";
р = new int;
*р = i;
}
myclass::myclass()
{
cout << "Освобождение р-памяти.\n";
delete p;
}
int main()
{
myclass a(10); // Вызывается обычный конструктор.
myclass b = a; // Вызывается конструктор копии.
return 0;
}
Результаты выполнения этой программы таковы.
Выделение p-памяти обычным конструктором.
Выделение p-памяти конструктором копии.
Освобождение р-памяти.
Освобождение р-памяти.
Как подтверждают результаты выполнения этой программы, при создании объекта а
вызывается обычный конструктор. Но когда объект а используется для инициализации объекта b, вызывается конструктор копии. Использование конструктора копии гарантирует,
что объект b выделит для своих членов данных собственную область памяти. Без конструктора копии объект b попросту представлял бы собой точную копию объекта а, а член а.р указывал бы на ту же самую область памяти, что и член b.р.
Следует иметь в виду, что конструктор копии вызывается только в случае выполнения инициализации. Например, следующая последовательность инструкций не вызовет конструктор копии, определенный в предыдущей программе:
myclass а(2), b(3);
// ...
b = а;
Здесь инструкция b = а выполняет операцию присваивания, а не операцию копирования.
Использование конструктора копии при возвращении функцией объекта
Конструктор копии также вызывается при создании временного объекта, который является результатом возвращения функцией объекта. Рассмотрим следующую короткую программу.
/* Конструктор копии вызывается в результате создания временного
объекта в качестве значения, возвращаемого функцией.
*/
#include
using namespace std;
class myclass {
public:
myclass() { cout << "Обычный конструктор.\n"; }
myclass(const myclass &obj) {cout << "Конструктор копии.\n";
}
};
myclass f()
{
myclass ob; // Вызывается обычный конструктор.
return ob; // Неявно вызывается конструктор копии.
}
int main()
{
myclass a; // Вызывается обычный конструктор.
а = f(); // Вызывается конструктор копии.
return 0;
}
Эта программа генерирует такие результаты.
Обычный конструктор.
Обычный конструктор.
Конструктор копии.
Здесь обычный конструктор вызывается дважды: первый раз при создании объекта
а в функции
main(), второй — при создании объекта
ob в функции
f(). Конструктор копии вызывается в момент, когда генерируется временный объект в качестве значения,
возвращаемого из функции
f().
Хотя "скрытые" вызовы конструкторов копии могут отдавать мистикой, нельзя отрицать тот факт, что практически каждый класс в профессионально написанных программах содержит явно определенный конструктор копии, без которого не избежать побочных эффектов, возникающих в результате создания по умолчанию побитовых копий объекта.
Конструкторы копии — а нельзя ли найти что-то попроще?Как уже неоднократно упоминалось в этой книге, C++ — очень мощный язык. Он
имеет множество средств, которые наделяют его широкими возможностями, но при этом его можно назвать сложным языком. Конструкторы копии представляют собой механизм, на который ссылаются многие программисты как на основной пример сложности языка,
поскольку это средство не воспринимается на интуитивном уровне. Начинающие программисты часто не понимают, почему так важен конструктор копии. Для многих не сразу становится очевидным ответ на вопрос: когда нужен конструктор копии, а когда —
нет. Эта ситуация часто выражается в такой форме:
"А не существует ли более простогоспособа?". Ответ также непрост:
и да, и нет!Такие языки, как Java и С#, не имеют конструкторов копии, поскольку ни в одном из них не создаются побитовые копии объектов. Дело в том, что как Java, так и C# динамически выделяют память для всех объектов, а программист оперирует этими объектами исключительно через ссылки. Поэтому при передаче объектов в качестве параметров функции или при возврате их из функций в копиях объектов нет никакой необходимости.
Тот факт, что ни Java, ни C# не нуждаются в конструкторах копии, делает эти языки проще, но за простоту тоже нужно платить. Работа с объектами исключительно посредством ссылок (а не напрямую, как в C++) налагает ограничения на тип операций, которые может выполнять программист. Более того, такое использование объектных ссылок в Java и C# не позволяет точно определить, когда объект будет разрушен. В C++ же объект всегда разрушается при выходе из области видимости.
Язык
C++ предоставляет программисту полный контроль над ситуациями,
складывающимися в программе, поэтому он несколько сложнее, чем Java и С#. Это — цена,
которую мы платим за мощность программирования.
Ключевое слово thisКлючевое слово this —
это указатель на объект, который вызывает функцию-член.При каждом вызове функции-члена ей автоматически передается указатель, именуемый ключевым словом
this, на объект, для которого вызывается эта функция. Указатель
this —
это
неявный параметр, принимаемый всеми функциями-членами. Следовательно, в любой функции-члене указатель this можно использовать для ссылки на вызывающий объект.
Как вы знаете, функция-член может иметь прямой доступ к закрытым (private) членам данных своего класса.
Например, у нас определен такой класс.
class cl {
int i;
void f() { ... };
// . . .
};
В функции f() можно использовать следующую инструкцию для присваивания члену i
значения 10.
i = 10;
В действительности предыдущая инструкция представляет собой сокращенную форму следующей.
this->i = 10;
Чтобы понять, как работает указатель this, рассмотрим следующую короткую программу.
#include
using namespace std;
class cl {
int i;
public:
void load_i(int val) { this->i = val; } // то же самое, что i = val int get_i() { return this->i; } // то же самое, что return i
};
int main()
{
cl o;
o.load_i (100);
cout << о.get_i();
return 0;
}
При выполнений эта программа отображает число 100.
Безусловно, предыдущий пример тривиален, но в нем показано, как можно использовать указатель this. Скоро вы поймете, почему указатель this так важен для программирования на
C++.
Важно! Функции-"друзья" не имеют указателя this, поскольку они не являются членами
класса. Только функции-члены имеют указатель this.
Скачать 9.37 Mb.