Файл: Информация и формы ее представления Информационные процессы и технологии.docx

Раздел 9 Объектно-ориентированное программирование

9.1. Описание класса

9.2. Описание объектов

3. Методы класса

9.4. Наследование

9.5. Иерархия классов

9.6. Виртуальные методы. Полиморфизм.

9.7. Контейнерные классы

Объектно-ориентированное, или объектное, программирование (ООП) — технология программирования, в которой основными концепциями являются понятия объектов и классов [2].

Идея классов является основой объектно-ориентированного программирования (ООП).

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

Объект - это конкретный экземпляр, построенный в памяти на основе своего шаблона (класса).

Основными принципами ООП являются:

1. 
   Инкапсуляция;
   
2. 
   Наследование;
   
3. 
   Полиморфизм.
   

1. Описание класса

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

Данные класса называются полями, а функции класса — методами. Поля и методы называются элементами класса.

При описании класса реализуется один из ключевых понятий ООП - инкапсуляция. Для начала приведу формальное определение этого понятия:

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

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

class <имя>

{

private:

<описание скрытых элементов>

public:

<описание доступных элементов>

};

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

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

Данные, описанные ключевым словом

---

publiс, напротив, доступны за пределами класса.

Поля класса:

• могут иметь любой тип, кроме типа этого же класса (но могут быть указателями или ссылками на этот класс);

• могут быть описаны с модификатором const, при этом они инициализируются только один раз (с помощью конструктора) и не могут изменяться.

Инициализация полей при описании не допускается.

Методы класса – это функции входящие в состав класса.

2. Описание объектов

Конкретные переменные типа «класс» называются экземплярами класса, или объектами.

Время жизни и видимость объектов зависит от вида и места их описания и подчиняется общим правилам языка С++.

Формат:

<имя класса> переменная;

Замечание: Объект находится в таком же отношении к своему классу, в каком переменная находится по отношению к своему типу.

Рассмотрим пример описания класса TPoint (точка):

1. 
   Точка характеризуется координатами: x и y – это свойства объекта;
   
2. 
   Над точкой можно выполнять следующие действия:
   

- можно задать её координаты;

- точку можно переместить (изменив координаты);

- можно получить координаты точки.

Далее приведем текст программы, который задает координаты точки, выводит их на экран, а, затем, перемещает точку в другие координаты.

#include "stdafx.h"

#include "iostream"

class TPoint

{ private:

int x,y;

public:

void InitPoint ( int newx, int newy)//метод инициализации точки

{ x = newx;

y = newy ;

}

void relmove ( int dx, int dy )//метод перемещения точки

{

x+= dx;

y += dy ;

}

int getx ( void )//метод возвращает координату х

{ return x ; }

int gety ( void ) //метод возвращает координату y

{ return y ; }

};

int main()

{

TPoint p;// описание объекта p

p.InitPoint(10,10);

std::cout<< "x="<
",\ty="<< p.gety()<<"\n";

p.relmove(5,10);// перемещение точки

std::cout<<"x="<< p.getx()<<",\ty="<< p.gety()<<"\n";

return 0;

}

В этом классе два скрытых поля — x и y, получить значения которых извне можно с помощью методов getx() и gety().

Все методы класса имеют непосредственный доступ к его скрытым полям.

В результате выполнения программы на экран будут выводиться первоначальные координаты точка, а затем новые координаты (рисунок 9.1).

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



Рисунок 9.1 – Результат работы программы

---

Методы класса

При вызове методов необходимо связать метод с объектом этого класса [2]. Поэтому имена объектов ( p ) связаны с именем функции (метода) операцией точка (.):

p.InitPoint(10,10);

p.relmove(5,10);

Замечание: Это напоминает доступ к полям структуры.

Вызов методов InitPoint() и relmove() приводило к изменению значений полей x и y. В следующем примере задание значений полей в методе Vvod() будет осуществляться с клавиатуры:

class TPoint

{ private:

int x,y;

public:

void InitPoint ( int newx, int newy)

{

x = newx;

y = newy ;

}

void Vvod()

{

std::cout<<"Vvedi X Y:";

std::cin>> x >> y;

}

. . .

};

Вставим вызов этого метода в главную программу:

int main()

{

TPoint p;// описание объекта

p.Vvod();

std::cout<<"x="<< p.getx()<<",\ty="<< p.gety()<<"\n";

return 0;

}

Результаты работы программы приведены на рисунке 9.2.



Рисунок 9.2 – Результат использования метода Vvod()
Конструкторы'>Конструкторы

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

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

Конструктор отличается от других методов:

1. 
   Имя конструктора совпадает с именем класса;
   
2. 
   У конструктора не существует возвращаемого значения.
   

Заменим метод InitPoint() на конструктор:

class TPoint

{ private:

int x,y;

public:

TPoint(int newx, int newy) // конструктор

{

x=newx;

y=newy;

}

void relmove ( int dx, int dy )

{x+= dx; y += dy ; }

int getx ( void )

{ return x ; }

int gety ( void )

{ return y ; }

};

int main(int argc, char *argv[])

{

TPoint p(10,10); //инициализация объекта р

std::cout<<"x="<< p.getx()<<",\ty="<< p.gety()<<"\n";

. . .

}

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

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

#include "stdafx.h"

#include "iostream"

class Counter

{ private:

int count;

public:

Counter ( ):count(0){ } //конструктор

void inc_count ( )//метод увеличения счетчика на 1

{count++; }

int get_count( )//метод возвращает значение счетчика

{ return count; }

};

int _tmain(int argc, _TCHAR* argv[])

{ Counter c1, c2;//создание объектов c1 и c2

std::cout<
std::cout<
c1.inc_count(); c1.inc_count(); //увеличение с1 на 2

c2.inc_count(); //увеличение с2 на 1

std::cout<
std::cout<
return 0;}

Результаты программы приведены на рисунке 9.3.



Рисунок 9.3. – Результаты работы программы

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

Counter ( ):count(0)

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

Если инициализируются несколько полей, то значения разделяются запятыми.

Деструкторы

Кроме специального метода конструктор, который вызывается при создании объекта, существует другой особый метод, автоматически вызываемый при уничтожении объекта, называемый деструктором [2].

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

class Prim

{ private: int dat;

public:

Prim(): dat(0)

{ }

Prim()

{ }

};

Наиболее распространённое применение деструкторов – освобождение памяти, выделенной конструктором при создании объекта.

Определение методов может быть реализовано как внутри самого класса, так и вне класса. Во втором случае внутри класса содержится лишь прототип функции, а сама функция определяется позже. Тогда перед именем функции указывается имя класса и символ ::

Вернемся к примеру класса TPoint. Рассмотрим в этом примере реализацию метода relmove()вне класса и добавим деструктор для класса TPoint.

class TPoint

{ private:

int x,y;

public:

TPoint(int newx, int newy)

{x=newx;y=newy; }

void relmove ( int dx, int dy );

int getx ( void )

{ return x ; }

int gety ( void )

{ return y ; }

Tpoint( ){ }

};

void TPoint::relmove(int dx, int dy)

{x+= dx; y += dy ; }

ЗАМЕЧАНИЯ:

1)Класс может иметь несколько конструкторов с разными параметрами для разных видов инициализации.

2)Конструктор, вызываемый без параметров, называется конструктором по умолчанию.

3)Деструктор вызывается автоматически, когда объект выходит из области видимости:

• для локальных объектов — при выходе из блока, в котором они объявлены;

• для глобальных — как часть процедуры выхода из main( );

• для объектов, заданных через указатели деструктор вызывается неявно при использовании операции delete.

Деструктор:

• не имеет аргументов и возвращаемого значения;

• не может быть объявлен, как const или static;

• не наследуется;

• может быть виртуальным.

Вернемся ко второму примеру, где был создан класс Counter. При решении разных задач может возникнуть необходимость инициализации счетчика разными значениями, а не только нулем. Для этого создадим еще один конструктор:

class Counter

{ private:

int count;

public:

Counter ( ):count(0)//конструктор, инициализирующий нулем

{ }

Counter (int c): count(c)//конструктор задает любое нач. значение

{ }

void inc_count ( )

{count++; }

int get_count( )

{ return count; }

Counter( ){} //деструктор

---

};

int _tmain(int argc, _TCHAR* argv[])

{

Counter c1, c2(3);

std::cout<
std::cout<
c1.inc_count();

c2.inc_count();

std::cout<
std::cout<
return 0;

}

Результат работы программы приведен на рисунке 9.4.



Рисунок 9.4. – Результат работы программы

с разными начальными значениями счетчиков

4. 1   ...   18   19   20   21   22   23   24   25   26

---

Наследование

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

Наследование – важная часть ООП. Выигрыш от него состоит в том, что наследование позволяет использовать существующий код несколько раз.

Простым называется наследование, при котором производный класс имеет одного родителя.

Формат описания производного класса:

В заголовке производного класса через двоеточие (:) указывается имя родительского класса.

сlass имя_класса :

<спецификатор доступа> имя_базоваго_класса

{

объявление элементов класса

};

При описании производного класса надо помнить, что поля и методы родительского класса могут быть унаследованы!!!

Рассмотрим правила наследования различных методов:

Конструкторы не наследуются, поэтому производный класс должен иметь собственные конструкторы [2].

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

Деструкторы также не наследуются, и если программист не описал в производном классе деструктор, он формируется по умолчанию.

Остальные методы могут наследоваться или переопределяться.

Поля, унаследованные из родительского класса, и которые определены в базовом классе как private, недоступны функциям производного класса.

Если они должны использоваться функциям, определенным в производном классе, можно, либо описать их в базовом классе, как protected, либо явно переопределить их в производном классе.

Вернемся к примеру счетчиков. Предположим, что нам понадобился метод, уменьшающий значение счетчика. Разработаем новый класс CountDown.

class Counter

{ protected: int count;

public:

Counter ( ):count(0){ }

Counter(int c): count(c){ }

void inc_count ( )

{count++; }

int get_count( )

{ return count; }

};

class CountDown: public Counter

{

public:

void dec_count ( )

{count--; }

};

Новый класс наследует: поле count и методы get_count( ) и inc_count().

---