Жасмин Бланшет - QT 4: программирование GUI на С++
Ниже приводится фрагмент программного кода, иллюстрирующий динамическое распределение памяти при помощи оператора new:
01 #include "point2d.h"
02 int main()
03 {
04 Point2D *point = new Point2D;
05 point->setX(1.0);
06 point->setY(2.5);
07 delete point;
08 return 0;
09 }
Оператор new возвращает адрес памяти для нового распределенного объекта. Мы сохраняем адрес в переменной указателя и обращаемся к объекту через этот указатель. Поработав с объектом, мы возвращаем занимаемую им память, используя оператор delete. В отличие от Java и C#, сборщик мусора отсутствует в С++; динамически распределяемые объекты должны явно освобождать занимаемую ими память при помощи оператора delete, когда они становятся больше ненужными. В главе 2 описывается механизм родственных связей Qt, который значительно упрощает управление памятью в программах, написанных на С++.
Если не вызвать оператор delete, память остается занятой до тех пор, пока не завершится программа. Это не создаст никаких проблем в приведенном выше примере, потому что память выделяется только для одного объекта, однако в программе, в которой постоянно создаются новые объекты, это может привести к нехватке машинной памяти. После удаления объекта переменная указателя по-прежнему будет хранить адрес объекта. Такой указатель является «повисшим указателем» и не должен использоваться для обращения к объекту. Qt предоставляет «умный» указатель QPointer<T>, который автоматически устанавливает себя в 0, если удаляется объект QObject, на который он ссылается.
В приведенном выше примере мы вызывали стандартный конструктор и функции setX() и setY() для инициализации объекта. Вместо этого можно было использовать конструктор с двумя параметрами:
Point2D *point = new Point2D(1.0, 2.5);
Кроме того, мы могли бы распределить объект в стеке следующим образом:
Point2D point;
point.setX(1.0);
point.setY(2.5);
Распределенные таким образом объекты автоматически освобождаются в конце блока, в котором они появляются.
Если мы не собираемся модифицировать объект при помощи указателя, можно объявить указатель как константный. Например:
const Point2D *ptr = new Point2D(1.0, 2.5);
double x = ptr->x();
double у = ptr->y();
// НЕ БУДЕТ КОМПИЛИРОВАТЬСЯ
ptr->setX(4.0);
*ptr = Point2D(4.0, 4.5);
Константный указатель ptr можно использовать лишь для вызова константных функций-членов, например x() и y(). Признаком хорошего стиля является объявление указателей константными, когда нет намерения модификации объекта с их помощью. Более того, если сам объект является константным, ничего не остается, кроме использования константного указателя для хранения его адреса. Применение ключевого слова const предоставляет компилятору информацию, позволяющую обнаруживать ошибки на ранних этапах и повысить производительность. C# имеет ключевое слово const с очень похожими свойствами. Ближайшим эквивалентом в Java является ключевое слово final, однако оно лишь защищает переменные от операций присваивания, но не от вызова «неконстантных» функций—членов объекта.
Указатели могут использоваться со встроенными типами так же, как с классами. Используемый в выражении унарный оператор * возвращает значение объекта, на который ссылается указатель. Например:
int i = 10;
int j = 20;
int *p = &i;
int *q = &j;
cout << *p << " equals 10" << endl;
cout << *q << " equals 20" << endl;
*p = 40;
cout << i << " equals 40" << endl;
p = q;
*p = 100;
cout << i << " equals 40" << endl;
cout << j << " equals 100" << endl;
Оператор ->, который можно использовать для обращения к членам объекта через указатель, является чисто синтаксическим приемом. Вместо ptr->member можно также написать (*ptr).member. Скобки обязательны, потому что оператор . (точка) имеет более высокий приоритет, чем унарный оператор *.
Указатели имели плохую репутацию в С и С++, причем доходило до того, что рекламировалось отсутствие указателей в языке Java. На самом деле указатели С++ концептуально аналогичны ссылкам в Java и C#, за исключением того, что указатели можно использовать для прохода по памяти, как мы это увидим позже в данном разделе. Более того, включение в Qt классов—контейнеров, использующих метод «копирования при записи» вместе со способностью С++ инстанцировать любой класс в стеке, означает возможность во многих случаях обойтись без указателей.
Ссылки
Кроме указателей С++ поддерживает также концепцию «ссылки». Подобно указателю, ссылка в С++ хранит адрес объекта. Основными отличиями являются следующие:
• Объявляются ссылки с применением оператора & вместо *.
• Ссылка должна быть инициализирована и не может в дальнейшем изменяться.
• С помощью ссылки обеспечивается прямое обращение к объекту; не предусмотрен специальный синтаксис, подобный операторам * или ->.
• Ссылка не может быть нулевой.
Ссылки в основном используются при объявлении параметров. По умолчанию в С++ используется передача параметров по значению, т.е. при передаче параметров функции последняя получает в действительности новую копию объекта. Ниже приводится определение функции, которая получает параметры, передаваемые по значению.
#include <cstdlib>
using namespace std;
double manhattanDistance(Point2D a, Point2D b)
{
return abs(b.x() - a.x()) + abs(b.y() - a.y());
}
Эта функция может вызываться следующим образом:
Point2D harlem(77.5, 50.0);
Point2D broadway(12.5, 40.0);
double distance = manhattanDistance(broadway, harlem);
Опытные С—программисты избегают операций копирования путем объявления параметров в виде указателей вместо значений:
double manhattanDistance(const Point2D *ap, const Point2D *bp)
{
return abs(bp->x() - ap->x()) + abs(bp->y() - ap->y());
}
После этого при вызове функции должны передаваться адреса вместо значений:
Point2D harlem(77.5, 50.0);
Point2D broadway(12.5, 40.0);
double distance = manhattanDistance(&broadway, &harlem);
Ссылки введены в С++ для того, чтобы сделать синтаксис менее громоздким и чтобы предотвратить передачу нулевого указателя. Если вместо указателей использовать ссылки, функция будет иметь следующий вид:
double manhattanDistance(const Point2D &a, const Point2D &b)
{
return abs(b.x() - a.x()) + abs(b.y() - a.y());
}
Ссылка объявляется аналогично указателю с использованием & вместо *. Однако при использовании ссылки можно забыть о том, что она является каким-то адресом памяти, и рассматривать ее как обычную переменную. Кроме того, вызов функции, принимающей ссылки в качестве аргументов, не требует специальной записи аргументов (не требуется задавать оператор &).
В конце концов, заменяя в списке параметров Point2D на const Point2D &, мы уменьшаем накладные расходы на вызов функции — вместо копирования 256 битов (размер четырех типов double) копируются только 64 или 128 бит, что зависит от размера указателя, принятого в целевой платформе.
В предыдущем примере использовались константные ссылки, не позволяющие модифицировать в функции объекты, обращение к которым осуществляется с помощью ссылок. Когда желателен этот побочный эффект, можно передавать неконстантную ссылку или указатель. Например:
void transpose(Point2D &point)
{
double oldX = point.x();
point.setX(point.y());
point.setY(oldX);
}
В некоторых случаях имеется ссылка и требуется вызвать функцию, которая принимает указатель и наоборот. Для преобразования ссылки в указатель можно просто использовать унарный оператор &:
Point2D point;
Point2D &ref = point;
Point2D *ptr = &ref;
Для преобразования указателя в ссылку используется унарный оператор *:
Point2D point;
Point2D *ptr = &point;
Point2D &ref = *ptr;
Ссылки и указатели представляются в памяти одинаково и часто могут использоваться вместо друг друга, из-за чего возникает естественный вопрос о том, в каких случаях что из них следует предпочесть. С одной стороны, ссылки имеют более удобный синтаксис, с другой стороны — указатели в любой момент можно вновь устанавливать на указатель другого объекта, они могут содержать нулевое значение и более явный синтаксис их применения часто является неприятностью, неожиданно оказавшейся благом. По этим причинам предпочтение часто отдается указателям, а ссылки почти исключительно используются при объявлении параметров функций совместно с ключевым словом const.
