ОБЪЕКТНО−ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ

Принципы объектно-ориентированного программирования

Объектно-ориентированное программирование (ООП) представляет собой подход к программированию. По мере развития вычислительной техники и усложнения решаемых задач возникали различные модели (т.н. парадигмы) программирования. Первые компиляторы (к ним прежде всего относится компилятор языка FORTRAN) поддерживали процедурную модель программирования, в основе которой лежит использование функций. Используя процедурную модель программирования, программисты могли писать программы до нескольких тысяч строк длиной. Следующий этап развития связан с переходом к структурной модели программирования (реализованной в компиляторах языков ALGOL, Pascal и С). Сутью структурного программирования является представление программы в виде совокупности взаимосвязанных процедур (или блоков) и тех которыми эти процедуры (или блоки) оперируют. При этом широко используются программные блоки и допускается только минимальное использование операторов GOTO. Сопровождение таких программ намного проще, чем процедурно-сориентированных. Используя структурное программирование, Передний программист может создавать и сопровождать программ до нескольких десятков тысяч строк длиной. Для написания более сложных задач понадобился новый подход к программированию, который и был реализован в модели ООП. Модель ООП основана на нескольких основополагающих концепциях.

Абстракция данных — это возможность определять новые типы данных, с которыми можно работать почти так же, как и с .основными типами данных. Такие типы часто называются абст­рактными типами данных, хотя термин «типы данных, опреде­ляемые пользователем» является более точным.

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

Для реализации этих двух основополагающих концепций в языке C++ используются классы. Термином класс определяется тип объек­тов. При этом каждый представитель (или экземпляр) класса назы­вается объектом. Каждый объект всегда имеет свое, уникальное состояние, определяемое текущими значениями его данных-членов (элементов-данных). Функциональное назначение класса определя­ется возможными действиями над объектами класса, которые зада­ются его функциями-членами (функциями-элементами или метода­ми). Причем термин «метод» чаще используется в литературе, по­священной языку Object Pascal. В каждом классе распределяется память для хранения данных, и устанавливаются допустимые опера­ции для каждого объекта данных данного типа. Создание объектов данного класса производится специальной функцией-членом, кото­рая называется конструктором, а уничтожение — другой специаль­ной функцией-членом, которая называется деструктором. Класс позволяет делать недоступными внутренние данные, представляя их как открытые (public), закрытые (private) и защищенные (protected). Класс устанавливает четко определенный интерфейс для взаимодействия объектов этого типа с остальным миром. Закры­тые коды или данные доступны только внутри этого объекта. С дру­гой стороны, открытые коды н данные, несмотря на то, что они за­даны внутри объекта, доступны для всех частей программы. Откры­тая часть объекта как раз и используется для создания интерфейса объекта с остальным миром. Полученными объектами можно управлять при помощи сообщений (или запросов), которые пред­ставляют собой просто вызовы функций-членов. Мы будем пользо­ваться термином запрос, чтобы не путать это понятие с сообщения­ми операционной системы Windows.

Наследование — это процесс, посредством которого один объ­ект может приобретать свойства другого. Это означает, что в ООП на основе уже существующих классов можно строить про­изводные классы. При этом производный класс (называемый так­же классом-потомком) наследует элементы-данные и функции-члены от своих родительских классов {классов-предков), добав­ляя к ним свои, которые позволяют ему реализовать черты, ха­рактерные только для него. Защищенные данные-члены и функ­ции-члены родительского класса доступны из производного клас­са. Кроме того, в производном классе наследуемые функции мо­гут быть переопределены. Таким образом, можно построить це лую иерархию классов, связанных между собой отношением ро­дитель — потомок. Термин базовый класс используется как сино­ним родительскому классу в иерархии классов. Если объект на­следует свои атрибуты (данные-члены и функции-члены) от од­ного родительского класса, говорят об одиночном ( или простом) наследовании. Если объект наследует атрибуты от нескольких родителей, говорят о множественном наследовании. Наследова­ние позволяет значительно сократить определение класса-потомка благодаря тому, что классы-потомки являются расшире­ниями родительских классов.

Полиморфизм (от греческого "polymorphos" -.множествен­ность форм) — это свойство кода вести себя по-разному, в зави­симости от ситуации, возникающей в момент выполнения. Поли­морфизм — это не столько характеристика объектов, сколько ха­рактеристика функций-членов класса и проявляется, в частности, в возможности использования одного имени функции-члена для функций, имеющих различные типы аргументов, если выполняе­мые функцией действия определяются типом переданных ей ар­гументов. Это называется перегрузкой функции. Полиморфизм может применяться и к операциям, то есть выполняемые опера­цией действия также могут зависеть от типа данных (операндов). Такой тип полиморфизма называется перегрузкой операции.

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

Теперь, когда мы рассмотрели основные концепции ООП, мы остановиться

на методологии ООП. В этой методологии задача представляется не в виде алгоритмической модели, а в виде совокупности объектов различных классов, которые обмениваются запросами. Объект, получивший запрос, отвечает на него посредством вызова соответствующей функции. Нахождение общности между типами объектов задачи — не простой процесс. Он осуществляется на стадии объектно-ориентированного проектирования. На этой стадии внача­ле рассматривается вопрос о применимости ООП к решаемой задаче. При этом для принятия решения о применимости ООП решающую роль играет та степень общности между классами, которую можно использовать, применяя механизмы наследова­ния и виртуальные функции. В некоторых задачах, таких как разработка графического интерфейса приложения, разработка приложений баз данных и компьютерная графика, простор для ООП поистине безграничен. Кроме того, методы ООП позволяют скрыть детали низкоуровневых сетевых протоколов. Поэтому они широко применяются при программировании приложений, рабо­тающих в сетях (как локальных, так и глобальных, например, в Internet). В случае принятия решения о применимости ООП на следующем этапе проектирования разрабатываются классы как строительные блоки для других типов и изучаются возможности выделения в классах тех свойств, которые могут быть переданы базовому классу. Затем проектируются те запросы, которыми будут обмениваться объекты, и осуществляется реализация раз­работанных объектов и запросов.

Классы

Понятие класса является наиболее важным в языке C++. Синтаксис описания класса похож на синтаксис описания структуры. Вот его основная форма:

class <имя_класса> {

//закрытые функции-члены и данные-члены

//класса

public:

//открытые функции-члены и данные-члены

//класса } <список_объектов>;

В описании класса <список_объектов> не является обя­зательным. Можно объявить объекты класса позже, по мере необходимости. Так обычно и поступают. Хотя <имя_класса> также необязательно, его обычно указывают. Причина в том, что <имя_класса> становится новым именем типа данных, кото­рое используется для объявления объектов этого класса.

Функции и переменные, объявленные внутри объявления (класса), становятся членами этого класса. Переменные, объявленные внутри объявления класса, называются данными-членами этого класса; функции, объявленные внутри объявления класса, называются функциями-членами класса. По умолчанию, все функции и переменные, объявленные в классе, становятся закрытыми для этого класса. Это означает, что они доступны только для других членов этого класса. Для объявления открытых членов класса используется ключевое слово public, за которым следует двоеточие. Все функции и переменные, объявленные после слова public, доступны и для других членов класса, и для в любой другой части программы, в которой содержится класс. Вот пример объявления класса:

class AnyClass {

//закрытый элемент класса int a; public:

int get_a() ;

void set_a(int num);

Хотя функции get_a() и set_a() и объявлены в классе AnyClass, они еще не определены. Для определения функции-члена нужно связать имя класса, частью которого является функция-член, с именем функции. Это достигается путем написания имени функции вслед за именем класса с двумя двоеточиями. о, записываемую в виде двух двоеточий, называют операцией расширения области видимости. Для задания функции используется следующая общая форма:

<Тип> <имя__класса>: :<имя_фунхции>

Ч> (<список_параметров>)

{ //тело функции

Ниже приведены примеры определения функций-членов get_a()

и set_a():

void AnyClass::get_a()

{

return a; }

int AnyClass::set_a(int num)

{

a = num;

}

Объявление класса AnyClass не приводит к созданию объ­ектов типа AnyClass. Чтобы создать объект соответствующего класса, нужно просто использовать имя класса как спецификатор типа данных. Например,

AnyClass obi, оb2;

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

Например,

obl.set_a(10); ob2.set_a(37);

Эти операторы устанавливают значения переменной а в объ­ектах оb1 и оb2. Каждый объект содержит собственную копию всех данных, объявленных в классе. Это значит, что значение переменной а в оb1 отлично от значения этой переменной в оb2.

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

class Coord

{

public: int x,y; void SetCoord(int _x, int _y);

void

Coord::SetCoord(int _x, int jy)

{ x = _x;

у= _ у;

}

int main ()

{

Coord pt; Coord *ptPtr = &pt; //указатель на объект

//...

pt.x = 0; //объект.член_класса

ptPtr->y =0; //указатель->член_класса

ptPtr->SetCoord(10,20);

//...

return 0;

}

Среди программистов часто возникает спор о том, какой метод доступа к членам класса - через оператор "." или через оператор "->" - работает быстрее. Внесем ясность в этот вопрос, выбора члена "." работает в точности так же, как оператор "->", за исключением того, что имени объекта предшествует неявно сгенерированный компилятором оператор адреса "&".

Таким образом, инструкцию

ObjName.FuncName();

компилятор трактует, как

(&ObjName)->FuncName();

Имена элементов класса могут также использоваться с именем класса, за которым следует операция разрешения видимости (двойное двоеточие), то есть вызов элемента имеет вид:

<имя_класса>::<имя_члена>

Подробнее эту форму вызова элементов класса мы рассмотрим позднее.

Язык C++ накладывает определенные ограничения на данные-члены класса:

· данные-члены не могут определяться с модификаторами auto, extern или register;

· данным-членом класса не может быть объект этого же класса (однако данным-членом может быть указатель или ссылка на объект этого класса, или сам объект друго­го класса).

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

Класс должен быть объявлен до использования его членов. Однако иногда в классе должен быть объявлен указатель или ссылка на объект другого класса еще до того, как он определен. В этом' случае приходится прибегать к неполному объявлению класса, которое имеет вид:

class <имя_класса>;

Рассмотрим пример.

//Неполное объявление класса

class PrevDecl;

class AnyClass

{

int x;

PrevDecl* obPtr;

public:

AnyClass(int _x){x = _x;

};

int main()

{

//...

return 0;

}

//Полное объявление класса

class PrevDecl

{

int a;

public:

PrevDecl() ;

};

Нельзя создать объект не полностью определенного класса. Попытка создания такого класса приводит к ошибке компиляции.

Заметим, что определение класса напоминает определение структуры, за исключением того, что определение класса:

· обычно содержит один или несколько спецификаторов доступа, задаваемых с помощью ключевых слов public, protected или private;

· вместо ключевого слова struct могут применяться
class или union;

· обычно включает в себя наряду с элементами данных
функции-члены;

· обычно содержит некоторые специальные функции-
члены, такие, как конструктор и деструктор.

Ниже приведены примеры определения классов с использованием ключевых слов struct и union.

struct Point

{

private:

int x;

int y;

public:

int GetXO ;

int GetY() ;

void SetX(int _x);

void SetY(int _y);

};

union Bits

{

Bits(unsigned int n);

void ShowBits() ;

unsigned int nun;

unsigned char с[sizeof(unsigned int)];

};

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

Таблица Спецификаторы доступа к классу

В C++ класс, структура и объединение рассматриваются как типы классов. Структура и класс подобны друг другу, за исклю­чением доступа по умолчанию: в структуре элементы имеют по умолчанию доступ public, в то время как в классе - private. Объединение, как и структура, по умолчанию предоставляет дос­туп public.

В приведенной ниже таблице 2 перечислены эти отличия.

Таблица 2.

Различие между классом, структурой и объединением

Структуры и объединения могут иметь конструкторы и дест­рукторы. Вместе с тем имеется несколько ограничений на ис­пользование объединений в качестве классов. Во-первых, они не могут наследовать какой бы то ни было класс, и они сами не мо­гут использоваться в качестве базового класса для любого друго­го типа. Короче говоря, объединения не поддерживают иерархию классов. Объединения не могут иметь членов с атрибутом static. Они также не должны содержать объектов с конструк­тором и деструктором. Рассмотрим пример использования объе­динения в качестве класса:

#include <iostream.h>

union Bits

{

Bits(unsigned int n);

void ShowBits ();

unsigned int num;

unsigned char с[sizeof(unsigned int )];

};

Bits::Bits(unsigned int n)

{

num = n;

}

void

Bits: : ShowBits ()

{

int i, j;

for (j=sizeof(unsigned int)-1; j>=0; j—)

{ cout « "Двоичное представление байта "

<< j << ":"

for (i=128; i; i»=l)

{ if (i & c[j]) cout << "I";

else cout << "0";

}

cout << "\n";

}

}

int mainQ

{

Bits ob(2000); ob.ShowBits();

return 0;

}

В этом примере осуществляется побайтовый вывод переданного объекту беззнакового целочисленного значения в двоичном виде.

Конструкторы и деструкторы.

Список инициализации элементов

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

#indude <iostream.h>

class AnyClass

{

int var;

public:

AnyClass(); //Конструктор

void Show() ;

};

AnyClass:: AnyClass()

{

cout << “В конструкторе\п”;

var = 0;

}

void

AnyClass: : Show ()

{

cout << var;

}

int main ()

{

AnyClass ob;

ob.Show() ;

//...

return 0;

}

В этом примере конструктор класса AnyClass выводит со­общение на экран и инициализирует значение закрытой перемен­ной класса var.

Заметим, что программист не должен писать код, вызы­вающий конструктор класса. Всю необходимую работу выпол­няет компилятор. Конструктор вызывается тогда, когда созда­ется объект его класса. Объект, в свою очередь, создается при выполнении оператора, объявляющего этот объект. Таким образом, в C++ оператор объявления переменной является выполнимым оператором. Для глобальных объектов конструктор вызывается тогда, когда начинается выполнение программы. Для локальных объектов эр вызывается всякий раз при выполнении оператора, объявляющего переменную. Функцией-членом, выполняющей действия, обратные конструктору, является деструктор. Эта функция-член вызывается удалении объекта. Деструктор обычно выполняет работу по освобождению памяти, занятой объектом. Он имеет то же имя, и класс, которому он принадлежит, с предшествующим символом ~ и не имеет возвращаемого значения. Рассмотрим пример, содержащего деструктор:

#indude <iostream.h>

class AnyClass

{

int var;

public:

AnyClass(); // Конструктор

~AnyClass(); //Деструктор

void Show();

};

AnyClass:: AnyClass() {

cout << "Мы в конструкторе\п";

var = 0;

}

AnyClass::~ AnyClass()

{ cout « "Мы в деструкторе\п";}

void

AnyClass::Show()

{ cout << var << "\n";

}

int main()

{

AnyClass ob; ob.Show() ;

return 0;

Деструктор класса вызывается в момент удаления объекта. Это означает, что для глобальных объектов он вызывается при завершении программы, а для локальных - когда они выходят из области видимости. Заметим, что невозможно получить указате­ли на конструктор и деструктор.

Обычно конструктор содержит параметры, которые позво­ляют при построении объекта задать ему некоторые аргумен­ты. В рассмотренном выше примере конструктор инициализи­ровал закрытую переменную var класса AnyClass значени­ем 0. Если нужно проинициализировать переменные класса, используется конструктор с параметрами. Модифицируем предыдущий пример:

iinclude <iostream.h>

class AnyClass

{

int a, b; public:

//Конструктор с параметрами

AnyClass(int x, int y); //Деструктор

~AnyClass();void Show();

AnyClass:: AnyClass(int x, int y)

{

cout << “Мы в конструкторе\n";

a = x;

b=y;

AnyClass:: ~ AnyClass()

{ cout << "Мы в деструкторе\n";

void

AnyClass::Show()

{

cout << a << "\n";

}

int main()

{

AnyClass ob(3,7);

ob.Show();

//...

return 0;

}

Здесь значение, переданное в конструктор при объявлении объекта ob, используется для инициализации закрытых перемен­ных а и b этого объекта.

Фактически синтаксис передачи аргумента конструктору с па­раметрами является сокращенной формой записи следующего выражения:

AnyClass ob = AnyClass(3,7);

Однако практически всегда используется сокращенная форма синтаксиса, приведенная в примере.

В отличие от конструктора, деструктор не может иметь пара­метров. Понятно, почему это сделано: незачем передавать аргу­менты удаляемому объекту.

Приведем правила, которые существуют для конструкторов:

· для конструктора не указывается тип возвращаемого зна­чения;

· конструктор не может возвращать значение;

· конструктор не наследуется;

· конструктор не может быть объявлен с модификатором
const, volatile, static или virtual.

Если в классе не определен конструктор, компилятор генерирует конструктор по умолчанию, не имеющий параметров.

Для деструкторов существуют следующие правила:

· деструктор не может иметь параметров;

· деструктор не может возвращать значение;

· деструктор не наследуется;

· класс не может иметь более одного деструктора;

· деструктор не может быть объявлен с модификатором

const, volatile, static или virtual.

Если в классе не определен деструктор, компилятор генериру­ет деструктор по умолчанию.

Подчеркнем еще раз: конструкторы и деструкторы в C++ вы­зываются автоматически, что гарантирует правильное создание и удаление объектов класса.

Не все приведенные выше правила станут вам ясны в данный момент.

Вернитесь к ним после прочтения нескольких последующих глав.

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

class AnyClass()

{

int a, b;

public:

AnyClass(int x, int y) ;

};

//Конструктор использует

//список инициализации

AnyClass::AnyClass(int x, int y): a(x), b(y)

Хотя выполнение инициализации в теле конструктора или с помощью списка инициализации — дело вкуса программиста, список инициализации является единственным методом инициа­лизации данных-констант и ссылок. Если членом класса является объект, конструктор которого требует задания значений одного или нескольких параметров, то единственно возможным спосо­бом его инициализации также является список инициализации.

Конструкторы по умолчанию и

конструкторы копирования

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

class T

{

public:

//Конструктор по умолчанию

Т();

//Конструктор с одним параметром;
//может быть использован как конструктор
//по умолчанию
Т(int I=0); ,

int main ()

{

Т obl(10); //Использует T::T(±nt)

Т ob2; //He верно; неоднозначность

//вызова. Т::Т() или T::T(lnt =0)

return 0;

}

|

В данном случае, чтобы устранить неоднозначность, достаточно удалить из

объявления класса конструктор по умолчанию.

Конструктор копирования (или конструктор копии) создает класса, копируя при этом данные из уже существующего i данного класса. В связи с этим он имеет в качестве един­ого параметра константную ссылку на объект класса

(const T&) или просто ссылку на объект класса (Т&). Использование первого предпочтительнее, так как последний не позволяет копировать константные объекты. Приведем пример использования конструктора копирования:

class Coord

{

int x, у;

public:

//Конструктор копирования

Coord(const Coord& src);

};

Coord::Coord(const Coord& src)

{

x = src.x;

у = src.у;

}

int main()

{

Coord ob1(2,9);

Coord ob2 = ob1;

Coord оbЗ(оb) ;

return 0;

}

Ссылка передается всякий раз, когда новый объект инициа­лизируется значениями существующего. Если вы не преду­смотрели конструктор копирования, компилятор генерирует конструктор копирования по умолчанию. В C++ различают поверхностное и глубинное копирование данных. При поверх­ностном копировании происходит передача только адреса от одной переменной к другой, в результате чего оба объекта ука­зывают на одни и те же ячейки памяти. В случае глубинного копирования происходит действительное копирование значе­ний всех переменных из одной области памяти в другую. Кон­структор копирования по умолчанию, созданный компилято­ром, создает буквальную (или побитную) копию объекта, то есть осуществляет поверхностное копирование. Полученная копия объекта скорее всего будет непригодной, если она со­держит указатели или ссылки. Действительно, если эти указа­тели или ссылки ссылаются на динамически распределенные объекты или на объекты, встроенные в копируемый объект, они будут недоступны в созданной копии объекта. Поэтому для классов, содержащих указатели и ссылки, следует вклю­чать в определение класса конструктор копирования, который будет осуществлять глубинное копирование, не полагаясь на создаваемый компилятором конструктор копирования по умолчанию. В этом конструкторе, как правило, выполняется звание динамических структур данных, на которые указатели на которые ссылаются члены класса. Класс должен содержать конструктор копирования, если он перегружает оператор присваивания.

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

Сгенерированный компилятором конструктор по умолчанию создает объект и вызывает конструкторы по умолчанию для базо­вых классов и членов-данных, но не предпринимает никаких дру­гих действий. Конструкторы базового класса и членов-данных я, только если они существуют, доступны и являются недвусмысленными. Когда конструируется объект производного класса, конструирование начинается с объектов его базовых классов и продвигается вниз по иерархии классов, пока не будет заданный объект. Подробнее этот вопрос будет рассмотрен в следующей главе.

Сгенерированный компилятором конструктор копирования -создает новый объект и выполняет почленное копирование содержимого исходного объекта. Если существуют конструкторы базового класса или члена-класса, — они вызываются; иначе выполняется побитное копирование. Если все базовые классы и классы членов-данных класса имеют конструкторы копирования, которые воспринимают const-аргумент, то сгенерированный ком­ам конструктор копирования воспринимает аргумент const T&. В противном случае он воспринимает аргумент Т& (без const).

Указатель this

Каждый объект в C++ содержит специальный указатель с именем this, который автоматически создается самим компилятором и указывает на данный объект. Типом this является Т*, где Т — тип класса данного объекта. Поскольку указатель this определёен в классе, область его действия — класс, в котором он определен. Фактически this является скрытым параметром класса, добавляемым самим компилятором к его определению. При вызове обычной функции-члена класса ей передается указа­тель this так, как если бы он был первым аргументом. Таким образом, вызов функции-члена

ObjName.FuncName(parl, par2);

компилятор трактует так:

ObjName.FuncName(&ObjName, parl, par2);

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

#include <iostream.h>

#include <string.h>

class T

{

public:

T(char*);

void Greeting();

char item[20];

}

T::T(char* name)

strcpy(item, name);

Greeting(); // Все три

this ->Greeting ().; // оператора

(*this).Greeting(); //эквивалентны

}

void

T: : Greeting ()

{

//Оба нижеследующих оператора эквивалентны

cout << "Hello, " << item << "\n";

cout << "Hello, " << this -> item << "\n";

}

int main()

{

T ob("dear.") ;

return 0;

}

Как можно видеть, внутри конструктора класса и функции-члена Greeting () обращения к данным-членам- класса и функ­циям-членам могут осуществляться как непосредственно по имени, так и с помощью указателя this. Поэтому на практике такое употребление указателя this встречается крайне редко. В основном указатель this используется для возврата указателя (в форме: return this;) или ссылки (в форме: return ;*this;) на соответствующий объект. Этот указатель находит широкое применение при перегрузке операторов.

Встраиваемые (inline-) функции

В C++ можно задать функцию, которая, фактически, не вызывается, а ее тело встраивается в программу в месте ее вызова. Она действует почти так же, как макроопределение с параметрами. По сравнению с обычными функциями встраиваемые (in-line) функ­ции обладают тем преимуществом, что их вызов не связан с передачей аргументов и возвратом результатов через стек и, следовательно, они выполняются быстрее обычных. Недостатком встраиваемых функций является то, что если они слишком большие и вызываются слишком часто, объем программы сильно возрастает. Из-за этого применение встраиваемых функций обычно ограничивается только очень простыми функциями.

Объявление встраиваемой функции осуществляется с помощью спецификатора inline, который вписывается перед опре­делением функции.

Следует иметь в виду, что спецификатор inline только формулирует требование компилятору сформировать встроенную э. Если компилятор не в состоянии выполнить это требование, функция компилируется как обычная. Компилятор не может сгенерировать функцию как встраиваемую, если она:

· содержит оператор цикла (for, while, do-while);

· содержит оператор switch или goto;