Программирование на C / C++ / Ален И. Голуб. Правила программирования на Си и Си++ [pdf]

};

то определение

Screen myScreen;

выделяет область памяти, достаточную для хранения четырех членов Screen. Имя myScreen относится к этой области. У каждого объекта класса есть собственная копия данных-членов. Изменение членов myScreen не отражается на значениях членов любого другого объекта типа Screen.

Область видимости объекта класса зависит от его положения в тексте программы. Он

class Screen {

// список членов

};

int main()

{

Screen mainScreen;

определяется в иной области, нежели сам тип класса:

}

Тип Screen объявлен в глобальной области видимости, тогда как объект mainScreen – в локальной области функции main().

Объект класса также имеет время жизни. В зависимости от того, где (в области видимости пространства имен или в локальной области) и как (статическим или нестатическим) он объявлен, он может существовать в течение всего времени выполнения программы или только во время вызова некоторой функции. Область видимости объекта класса и его время жизни ведут себя очень похоже. (Понятия области видимости и времени жизни введены в главе 8.)

Объекты одного и того же класса можно инициализировать и присваивать друг другу. По умолчанию копирование объекта класса эквивалентно копированию всех его членов.

Screen bufScreen = myScreen;

//bufScreen._height = myScreen._height;

//bufScreen._width = myScreen._width;

//bufScreen._cursor = myScreen._cursor;

Например:

// bufScreen._screen = myScreen._screen;

Указатели и ссылки на объекты класса также можно объявлять. Указатель на тип класса

разрешается инициализировать адресом объекта того же класса или присвоить ему такой адрес. Аналогично ссылка инициализируется l-значением объекта того же класса. (В объектно-ориентированном программировании указатель или ссылка на объект базового

int main()

{

Screen myScreen, bufScreen[10]; Screen *ptr = new Screen; myScreen = *ptr;

delete ptr;

ptr = bufScreen; Screen &ref = *ptr;

Screen &ref2 = bufScreen[6];

класса могут относиться и к объекту производного от него класса.)

}

По умолчанию объект класса передается по значению, если он выступает в роли аргумента функции или ее возвращаемого значения. Можно объявить формальный

параметр функции или возвращаемое ею значение как указатель или ссылку на тип класса. (В разделе 7.3 были представлены параметры, являющиеся указателями или ссылками на типы классов, и объяснялось, когда их следует использовать. В разделе 7.4 с этой точки зрения рассматривались типы возвращаемых значений.)

Для доступа к данным или функциям-членам объекта класса следует пользоваться соответствующими операторами. Оператор “точка” (.) применяется, когда операндом является сам объект или ссылка на него; а “стрелка” (->) – когда операндом служит

#include "Screen.h"

bool isEqual( Screen& s1, Screen *s2 )

{ // возвращает false, если объекты не равны, и true - если равны

if (s1.height() != s2->height() || s2.width() != s2->width() )

return false;

for ( int ix = 0; ix < s1.height(); ++ix ) for ( int jy = 0; jy < s2->width(); ++jy )

if ( s1.get( ix, jy ) != s2->get( ix, jy ) ) return false;

return true; // попали сюда? значит, объекты равны

указатель на объект:

}

isEqual() – это не являющаяся членом функция, которая сравнивает два объекта Screen. У нее нет права доступа к закрытым членам Screen, поэтому напрямую обращаться к ним она не может. Сравнение проводится с помощью открытых функций- членов данного класса.

Для получения высоты и ширины экрана isEqual() должна пользоваться функциями- членами height() и width() для чтения закрытых членов класса. Их реализация тривиальна:

class Screen { public:

int height() { return _height; } int width() { return _width; }

//...

private:

short _heigh, _width;

//...

};

Применение оператора доступа к указателю на объект класса эквивалентно последовательному выполнению двух операций: применению оператора разыменования (*) к указателю, чтобы получить адресуемый объект, и последующему применению оператора “точка” для доступа к нужному члену класса. Например, выражение

s2->height()

можно переписать так:

(*s2).height()

Результат будет одним и тем же.

13.3. Функции-члены класса

Функции-члены реализуют набор операций, применимых к объектам класса. Например,

class Screen { public:

void home() { _cursor = 0; }

char get() { return _screen[_cursor]; } char get( int, int );

void move( int, int );

bool checkRange( int, int ); int height() { return _height; } int width() { return _width; } // ...

для Screen такой набор состоит из следующих объявленных в нем функций-членов:

};

Хотя у любого объекта класса есть собственная копия всех данных-членов, каждая

Screen myScreen, groupScreen; myScreen.home();

функция-член существует в единственном экземпляре: groupScreen.home();

При вызове функции home() для объекта myScreen происходит обращение к его члену _cursor. Когда же эта функция вызывается для объекта groupScreen, то она обращается

к члену _cursor именно этого объекта, причем сама функция home() одна и та же. Как же может одна функция-член обращаться к данным-членам разных объектов? Для этого применяется указатель this, рассматриваемый в следующем разделе.

13.3.1. Когда использовать встроенные функции-члены

Обратите внимание, что определения функций home(), get(), height() и width() приведены прямо в теле класса. Такие функции называются встроенными. (Мы говорили об этом в разделе 7.6.)

Функции-члены можно объявить в теле класса встроенными и явно, поместив перед

class Screen { public:

//использование ключевого слова inline

//для объявления встроенных функций-членов inline void home() { _cursor = 0; }

inline char get() { return _screen[_cursor]; }

//...

типом возвращаемого значения ключевое слово inline:

};

Определения home() и get() в приведенных примерах эквивалентны. Поскольку ключевое слово inline избыточно, мы в этой книге не пишем его явно для функций- членов, определенных в теле класса.

Функции-члены, состоящие из двух или более строк, лучше определять вне тела. Для

идентификации функции как члена некоторого класса требуется специальный синтаксис объявления: имя функции должно быть квалифицировано именем ее класса. Вот как

#include <iostream> #include "screen.h"

// имя функции-члена квалифицировано именем Screen:: bool Screen::checkRange( int row, int col )

{// проверить корректность координат if ( row < 1 || row > _height ||

col < 1 || col > _width ) { cerr << "Screen coordinates ( "

<<row << ", " << col

<<" ) out of bounds.\n"; return false;

}

return true;

выглядит определение функции checkRange(), квалифицированное именем Screen:

}

Прежде чем определять функцию-член вне тела класса, необходимо объявить ее внутри тела, обеспечив ее видимость. Например, если бы перед определением функции checkRange() не был включен заголовочный файл Screen.h, то компилятор выдал бы сообщение об ошибке. Тело класса определяет полный список его членов. Этот список не может быть расширен после закрытия тела.

Обычно функции-члены, определенные вне тела класса, не делают встроенными. Но объявить такую функцию встроенной можно, если явно добавить слово inline в объявление функции внутри тела класса или в ее определение вне тела, либо сделав то и другое одновременно. В следующем примере move() определена как встроенная функция-

inline void Screen::move( int r, int c )

{ // переместить курсор в абсолютную позицию

if ( checkRange( r, c ) ) // позиция на экране задана корректно?

{

int row = (r-1) * _width; // смещение начала строки _cursor = row + c - 1;

}

член класса Screen:

}

class Screen { public:

inline char get( int, int );

// объявления других функций-членов не изменяются

Функция get(int, int) объявляется встроенной с помощью слова inline:

};

Определение функции следует после объявления класса. При этом слово inline можно

char Screen::get( int r, int c )

{

опустить:

}

Так как встроенные функции-члены должны быть определены в каждом исходном файле, где они вызываются, то встроенную функцию, не определенную в теле класса, следует поместить в тот же заголовочный файл, в котором определен ее класс. Например,

представленные ранее определения move() и get() должны находиться в заголовочном файле Screen.h после определения класса Screen.

13.3.2. Доступ к членам класса

Говорят, что определение функции-члена принадлежит области видимости класса независимо от того, находится ли оно вне или внутри его тела. Отсюда следуют два вывода:

∙в определении функции-члена могут быть обращения к любым членам класса, открытым или закрытым, и это не нарушает ограничений доступа;

∙когда функция-член обращается к членам класса, операторы доступа “точка” и “стрелка” не необходимы.

#include <string>

void Screen::copy( const Screen &sobj )

{

//если этот объект и объект sobj - одно и то же,

//копирование излишне

//мы анализируем указатель this (см. раздел 13.4)

if ( this != &sobj )

{

_height = sobj._height; _width = sobj._width; _cursor = 0;

//создаем новую строку;

//ее содержимое такое же, как sobj._screen _screen = sobj._screen;

}

Например:

}

Хотя _screen, _height, _width и _cursor являются закрытыми членами класса Screen, функция-член copy() работает с ними напрямую. Если при обращении к члену отсутствует оператор доступа, то считается, что речь идет о члене того класса, для

#include "Screen.h"

int main()

{

Screen s1;

// Установить s1

Screen s2; s2.copy(s1);

// ...

которого функция-член вызвана. Если вызвать copy() следующим образом:

}

то параметр sobj внутри определения copy() соотносится с объектом s1 из функции main(). Функция-член copy() вызвана для объекта s2, стоящего перед оператором “точка”. Для такого вызова члены _screen, _height, _width и _cursor, при обращении к которым внутри определения этой функции нет оператора доступа, – это члены объекта s2. В следующем разделе мы рассмотрим доступ к членам класса внутри определения функции-члена более подробно и, в частности, покажем, как для поддержки такого доступа применяется указатель this.

13.3.3. Закрытые и открытые функции-члены

Функцию-член можно объявить в любой из секций public, private или protected тела класса. Где именно это следует делать? Открытая функция-член задает операцию, которая может понадобиться пользователю. Множество открытых функций-членов

составляет интерфейс класса. Например, функции-члены home(), move() и get() класса Screen определяют операции, с помощью которых программа манипулирует объектами этого типа.

Поскольку мы прячем от пользователей внутреннее представление класса, объявляя его члены закрытыми, то для манипуляции объектами типа Screen необходимо предоставить открытые функции-члены. Такой прием – сокрытие информации – защищает написанный пользователем код от изменений во внутреннем представлении.

Внутреннее состояние объекта класса также защищено от случайных изменений. Все модификации объекта производятся с помощью небольшого набора функций, что существенно облегчает сопровождение и доказательство правильности программы.

До сих пор мы встречались лишь с функциями, поддерживающими доступ к закрытым членам только для чтения. Ниже приведены две функции set(), позволяющие

class Screen { public:

void set( const string &s ); void set( char ch );

// объявления других функций-членов не изменяются

пользователю модифицировать объект Screen. Добавим их объявления в тело класса:

};

void Screen::set( const string &s )

{ // писать в строку, начиная с текущей позиции курсора

int space = remainingSpace(); int len = s.size();

if ( space < len ) {

cerr << "Screen: warning: truncation: "

<<"space: " << space

<<"string length: " << len << endl;

len = space;

}

_screen.replace( _cursor, len, s ); _cursor += len - 1;

}

void Screen::set( char ch )

{

if ( ch == '\0' )

cerr << "Screen: warning: "

<< "null character (ignored).\n"; else _screen[_cursor] = ch;

Далее следуют определения функций:

}

В реализации класса Screen мы предполагаем, что объект Screen не содержит двоичных нулей. По этой причине set() не позволяет записать на экран нуль.

Представленные до сих пор функции-члены были открытыми, их можно вызывать из любого места программы, а закрытые вызываются только из других функций-членов (или

друзей) класса, но не из программы, обеспечивая поддержку другим операциям в реализации абстракции класса. Примером может служить функция-член remainingSpace

class Screen { public:

// объявления других функций-членов не изменяются private:

inline int remainingSpace();

класса Screen(), использованная в set(const string&).

};

inline int Screen::remainingSpace()

{

int sz = _width * _height; return ( sz - _cursor );

remainingSpace() сообщает, сколько места осталось на экране:

}

(Детально защищенные функции-члены будут рассмотрены в главе 17.)

Следующая программа предназначена для тестирования описанных к настоящему

#include "Screen.h" #include <iostream>

int main() {

Screen sobj(3,3); // конструктор определен в разделе 13.3.4 string init("abcdefghi");

cout << "Screen Object ( "

<<sobj.height() << ", "

<<sobj.width() << " )\n\n";

//Задать содержимое экрана string::size_type initpos = 0;

for ( int ix = 1; ix <= sobj.width(); ++ix ) for ( int iy = 1; iy <= sobj.height(); ++iy )

{

sobj.move( ix, iy ); sobj.set( init[ initpos++ ] );

}

// Напечатать содержимое экрана

for ( int ix = 1; ix <= sobj.width(); ++ix )

{

for ( int iy = 1; iy <= sobj.height(); ++iy ) cout << sobj.get( ix, iy );

cout << "\n";

}

return 0;

моменту функций-членов:

}

Откомпилировав и запустив эту программу, мы получим следующее:

Screen Object ( 3, 3 )

abc def ghi

13.3.4. Специальные функции-члены

Существует специальная категория функций-членов, отвечающих за такие действия с объектами, как инициализация, присваивание, управление памятью, преобразование типов и уничтожение. Такие функции называются конструкторами. Они вызываются компилятором неявно каждый раз, когда объект класса определяется или создается оператором new. В объявлении конструктора его имя совпадает с именем класса. Вот, например, объявление конструктора класса Screen, в котором заданы значения по

class Screen { public:

Screen( int hi = 8, int wid = 40, char bkground = '#'); // объявления других функций-членов не изменяются

умолчанию для параметров hi, wid и bkground:

};

Screen::Screen( int hi, int wid, char bk ) :

//все позиции инициализируются

//символом '#'

{// вся работа проделана в списке инициализации членов

//этот список обсуждается в разделе 14.5

Определение конструктора класса Screen выглядит так:

(В главе 14 конструкторы, деструкторы и операторы присваивания рассматриваются более подробно. В главе 15 обсуждаются конвертеры и функции управления памятью.)

13.3.5. Функции-члены со спецификаторами const и volatile

Любая попытка модифицировать константный объект из программы обычно помечается

const char blank = ' ';

компилятором как ошибка. Например:

Однако объект класса, как правило, не модифицируется программой напрямую. Вместо этого вызывается та или иная открытая функция-член. Чтобы не было “покушений” на константность объекта, компилятор должен различать безопасные (те, которые не

изменяют объект) и небезопасные (те, которые пытаются это сделать) функции-члены:

Проектировщик класса может указать, какие функции-члены не модифицируют объект,

class Screen { public:

char get() const { return _screen[_cursor]; } // ...

объявив их константными с помощью спецификатора const:

};

Для класса, объявленного как const, могут быть вызваны только те функции-члены, которые также объявлены со спецификатором const. Ключевое слово const помещается между списком параметров и телом функции-члена. Для константной функции-члена, определенной вне тела класса, это слово должно присутствовать как в объявлении, так и в определении: