С++ для начинающих |
594 |
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, то она обращается
С++ для начинающих |
595 |
к члену _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, то компилятор выдал бы сообщение об ошибке. Тело класса определяет полный список его членов. Этот список не может быть расширен после закрытия тела.
С++ для начинающих |
596 |
Обычно функции-члены, определенные вне тела класса, не делают встроенными. Но объявить такую функцию встроенной можно, если явно добавить слово 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( r, c ); |
// |
устанавливаем _cursor |
return get(); |
// |
вызываем другую функцию-член get() |
опустить:
}
Так как встроенные функции-члены должны быть определены в каждом исходном файле, где они вызываются, то встроенную функцию, не определенную в теле класса, следует поместить в тот же заголовочный файл, в котором определен ее класс. Например,
представленные ранее определения move() и get() должны находиться в заголовочном файле Screen.h после определения класса Screen.
13.3.2. Доступ к членам класса
Говорят, что определение функции-члена принадлежит области видимости класса независимо от того, находится ли оно вне или внутри его тела. Отсюда следуют два вывода:
∙в определении функции-члена могут быть обращения к любым членам класса, открытым или закрытым, и это не нарушает ограничений доступа;
∙когда функция-член обращается к членам класса, операторы доступа “точка” и “стрелка” не необходимы.
С++ для начинающих |
597 |
#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 тела класса. Где именно это следует делать? Открытая функция-член задает операцию, которая может понадобиться пользователю. Множество открытых функций-членов
С++ для начинающих |
598 |
составляет интерфейс класса. Например, функции-члены 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() не позволяет записать на экран нуль.
Представленные до сих пор функции-члены были открытыми, их можно вызывать из любого места программы, а закрытые вызываются только из других функций-членов (или
С++ для начинающих |
599 |
друзей) класса, но не из программы, обеспечивая поддержку другим операциям в реализации абстракции класса. Примером может служить функция-член 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;
моменту функций-членов:
}