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

Конечно, члены не могут использовать спецификаторы классов памяти auto, extern или register. 

Существует два основных отличия между описанием функции-члена и обычной функции. 
    •   Имени функции-члена предшествует имя класса и оператор разрешения 
области видимости. 
    •   Внутри функции-члена операторы имеют прямой доступ к членам класса. 

    В новом классе TTime — три дополнения. Во-первых, спецификатор доступа 
private (строка 5) делает закрытыми в классе данные-члены в строках 6-10. 
Благодаря этому изменению только функции-члены класса могут непосредственно 
ссылаться на эти данные-члены. Запомните следующее правило: закрытые (private) 
члены класса доступны только членам этого класса и никому более, закрытые 
члены невидимы вне класса. 


    ЗАМЕЧАНИЕ 

    Члены класса закрыты по умолчанию, и, действительно; строка 5 в 
CLASS2.CPP — лишняя. Конечно, для внесения ясности в программу отмечать 


    В классе могут присутствовать многочисленные открытые и закрытые секции, 
располагающиеся в произвольном порядке. Вы можете повторять спецификаторы 
доступа private и public в объявлении класса (строки 5 и 11) столько раз, 
сколько понадобится. Хотя это не показано в примере, функции-члены также могут 

Для использования закрытых данных-членов TTime существует лишь один законный 
способ — вызов открытых функций-членов класса. Непосредственный 

Заметьте, что функции в классе имеют доступ друг к другу, т.е. две функции класса 
могут вызывать одна другую. 


    Когда подобный оператор вызывает функцию-член, C++ передает функции адрес 
объекта, в данном случае адрес appointment. Внутри функции-члена адрес объекта 
доступен с помощью специального ключевого слова this. Все функции-члены 
получают указатель this, ссылающийся на объект класса, для которого 
функция-член была вызвана. В листинге 13.5, в строке 12, функции-члену 
ChangeTime() передается указатель this, в котором хранится адрес appointment. 
Иначе говоря, подобным образом функции-члены ссылаются на объекты класса, для 
которых они были вызваны.
    Вы можете использовать this в качестве указателя на объект типа класса. 
Например, строку 21 в листинге 13.4 можно было написать следующим образом: 
    m = this->month; 
    Говоря обычным языком, этот оператор присваивает ссылочному параметру m 
значение month — члена объекта класса, адресуемого this. Конечно, в 
большинстве случаев нет нужды в непосредственном использовании this. Оператор 
    m = month; по умолчанию ссылается на month — член объекта класса, на 
который ссылается this. 


    Класс TTime в TIME2.H идентичен TTime в TIME1.H за исключением того, что в 
объявлении присутствует лишь одно закрытое длинное целое dt. Удалены 
индивидуальные компоненты month, day, year, hour и minute. Конечно, несмотря 
на проведенные изменения, открытые функции-члены — те же самые, и нет нужды в 
изменении операторов, в которых используется класс TTime. 
    Собственно функции-члены нуждаются в изменении, но, по крайней мере, эта 
работа ограничена известным числом легко идентифицируемых функций.


    Изменение формата данных для упрощения кода — сберегающий время стиль 
оптимизации программ. С помощью ООП и классов C++ изменения фундаментальной 
структуры данных не обязательно потребуют соответствующих изменений 
операторов, использующих эту информацию. Как показано в листинге 13.8, 
основная программа в проекте "не помнит" об основных модификациях, сделанных в 
классе TTime. 

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


    Хотя это наблюдение верно, не забывайте, что одно из основных достоинств 
класса заключается в запрещении доступа к данным, что упрощает поддержку. 
Насколько велика ценность нескольких вызовов функции для стабильности вашей 
программы и смогут ли они упростить внесение в нее изменений? 
    В большинстве случаев вызовы функций-членов вместо прямого доступа к 
данным-членам заметно сказываются на быстродействии программы. Конечно, в наше 
время необходима предельная эффективность. Для этого C++ позволяет объявлять 
классы с встраиваемыми функциями-членами. Хотя встраиваемые функции-члены 


    Тело функции-члена Display() заключено в фигурные скобки сразу после 
заголовка функции в объявлении класса.
    Как и в случае с обычными встраиваемыми функциями, C++ может и не вставить 
функцию-член непосредственно в скомпилированный код. 
   Вы также можете объявить встраиваемую функцию-член с помощью ключевого слова inline в модуле 
реализации класса. 
    Конечно, поставив inline перед именем функции, можно и не добиться 
желаемого результата, поскольку реализация встраиваемых функций-членов должна 
быть доступна компилятору до того, как эта функция будет вызвана. В 
большинстве случаев встраиваемые функции-члены лучше всего распознаются, когда 
они объявлены непосредственно в классе. 

    Значения функций-членов по умолчанию не приводятся в заголовке функции в 
строке 21. Значения по умолчанию могут присутствовать только в объявлении функции-члена. 

Объект типа TTime не должен выходить из области видимости без 
освобождения выделенной этому объекту памяти, иначе это приведет к ошибкам, 
связанным с нехваткой памяти. 

деструкторе TTime удаляет dts. (Можно не проверять dts на содержание 
ненулевого значения; оператор delete проигнорирует нулевые аргументы-указатели.) 

Когда объект выходит из области видимости, C++ вызывает его деструктор. 

вызовами функции atexitO (см. книгу Освоение Borland C++ 4.5. Энциклопедия функции). Конечно, 
деструкторы не вызываются, если программа заканчивается с помощью обращения к abort(). 

    Если вы вызываете exit() для того, чтобы завершить программу, деструкторы 
глобальных объектов классов вызываются как обычно, а деструкторы любых 
существующих автоматических переменных, локальных в функции (включая и те, 
которые локальны в mainO), не вызываются.

    sp = (*pToday).GetSTime(); 

    присваивает переменной sp (которая объявлена, как const char *sp;) 
результат функции-члена GetSTLmeO для объекта класса, на который ссылается 
pToday. Конечно, оператор 

    sp = pToday->GetSTime(); 

    ЗАМЕЧАНИЕ 

    Не путайте жизнь указателя с жизнью объекта, на который он ссылается. 
Глобальный указатель существует до тех пор, пока программа не завершится, но 
он может ссылаться на множество объектов класса, создаваемых с помощью new и 
удаляемых с помощью delete. Аналогично, автоматические указатели, объявленные 
локальными в функции, создаются при выполнении функции и уничтожаются при ее 
завершении. Но объекты, на которые ссылаются указатели, имеют глобальную 
область дейтвия и должны удаляться явным образом. В функции f(), если вы 
вызовете new для создания объекта в куче, этот объект останется в памяти даже 
после завершения функции. Вы должны явным образом удалять любой подобный 
объект, если вы не хотите, чтобы он оставался в памяти после возврата из  из функции.


    TTime tenTimes[10]; 
    Существует только одно строгое правило, которое необходимо помнить: 
объекты класса, которые будет содержать массив, должны иметь конструкторы по 
умолчанию. Когда создается массив объектов класса, подобный tenTimes, C++ 
вызывает конструктор класса по умолчанию для каждого объекта массива. В случае 
с tenTimes, C++ вызывает 10 раз конструктор по умолчанию TTime, инициализируя 
таким образом объекты tenTimes[0] — tenTimes[9] текущими датой и временем. 


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

удаление подобных массивов вызывает проблемы. Из-за неспособности С и C++ 
различать указатели и массивы программы должны использовать особую форму 
оператора delete[] для обеспечения вызова всех деструкторов при удалении 


    В классе может быть объявлен деструктор (но только один). Деструктор 
обычно удаляет динамические переменные, на которые ссылаются данные-члены 
объекта класса, но может выполнять и другие функции очистки. C++ вызывает 
деструктор, когда объект класса выходит из области видимости или когда он удаляется. 

