Объектно-ориентированное программирование.
Объектно-ориентированное программирование (ООП) – это система принципов и способов организации и построения программ, которая основана на представлении программы в виде совокупности взаимодействующих некоторым образом объектов.
Для каждого объекта определяются конкретные характеристики, которые вытекают из условия задачи, то есть какие-то из них можно опустить, а какие-то оставить. Характеристики, которые определяются для конкретного объекта, называются свойствами. Сам объект может управлять своими свойствами при помощи методов – наборов функций, которые могут изменять состояние объекта (значения переменных в программе). Полностью объект описывается свойствами и методами управления свойствами.
Основным понятием ООП в языке Си++ является понятие класса.
Класс – это произвольный структурированный тип, включающий в себя свойства и методы. Класс будет соответствовать определённому объекту предметной области.
Классы обладают тремя свойствами (характеристиками как типа данных):
1. инкапсуляция,
2. наследование,
3. полиморфизм.
Инкапсуляция – это свойство класса как типа данных содержать в себе одновременно переменные и функции их обработки, то есть свойства и методы.
Наследование предполагает возможность использования свойств и методов уже созданного класса для определения нового класса, то есть можно создать так называемый базовый класс и производные классы, которые могут содержать свойства и методы базового класса. Таким образом, строится иерархия классов, или библиотека.
Полиморфизм – это свойство класса, позволяющее определить одно и то же по имени, но разное по смыслу действие.
Основные этапы ООП:
1. Определить основные объекты предметной области и их свойства.
2. Определить принципы взаимодействия этих объектов, таким образом, для каждого объекта определить методы управления свойствами.
3. По первым двум пунктам построить иерархию класса, то есть должны быть использованы свойства инкапсуляции, наследования и полиморфизма.
В результате может быть создана библиотека классов.
Описание классов.
Классы описываются в отдельных головных файлах, затем эти файлы подключаются в главной функции с помощью директивы include.
Простейшим образом классы можно определить с помощью конструкции:
class <имя класса>
{
<компоненты класса< (свойства и методы класса)
};
где class – служебное слово; <имя класса> – произвольно выбираемый идентификатор; <компоненты класса> – определение и описание типизированных данных (объектов) и принадлежащих классу функций (методов).
В проекте стандарта языка Си++ указано, что компонентами класса могут быть данные, функции, классы, перечисления, битовые поля, дружественные функции, дружественные классы и имена типов. В простейшем случае компоненты класса – это типизированные данные (базовые и производные) и функции. Заключённый в фигурные скобки список компонентов называют телом класса.
Телу класса предшествует заголовок. В простом случае заголовок класса включает ключ класса и его имя. Определение класса всегда заканчивается точкой с запятой. В качестве простейшего примера класса можно использовать структуру, но класс отличается от обычного структурированного типа, по крайней мере, включением компонентных функций. Например, следующая конструкция вводит класс «комплексное число» :
class complex // Вариант класса «комплексное число»
{
float re; // Вещественная часть
float im; // Мнимая часть
// Определение значения комплексного числа
void def(float re1, float im1)
{
re=re1; im=im1;
}
// Вывести на экран значение комплексного числа
void disp( )
{
cout << “real=” << re;
cout << “,imag=” << im;
}
};
В отличие от структурного типа в класс (тип) complex, кроме компонентных данных (re, im), включены две компонентные функции def() и disp( ).
Класс (как и его частный случай – структура), определённый пользователем, обладает правами типа. Следовательно, можно определить и описать объекты класса и описать объекты класса и создавать производные типы.
Итак, класс – это тип, определённый программистом. Каждый тип служит для определения объектов. Для описания объектов класса используется конструкция:
<имя класса> <имя объекта>;
Например:
complex x1,x2,D; // При объявлении класса complex
complex *point=&D; // Указатель на объект класса complex
complex dim[8]; // Массив объектов класса complex
complex &Name=x2; // Ссылка на объект класса complex
В определении объекта (класса) входят данные (элементы), соответствующие компонентным данным класса. Компонентные функции класса позволяют обработать данные конкретных объектов класса. Но в отличие от компонентных данных компонентные функции не тиражируются при создании конкретных объектов класса. Если перейти на уровень реализации, то место в памяти выделяется именно для элементов каждого объекта класса. Определение объектов класса предусматривает выделение участка памяти и деление этого участка на фрагменты, соответствующие отдельным элементам объекта, каждый из которых отображает отдельный компонент данных класса. Таким образом, и в объекте x1, и в объекте dim[8] класса complex входит по два элемента типа float, представляющих вещественную и мнимую части комплексных чисел.
Как только объекты класса определены, появляется возможность обращения к его компонентам, во-первых, с помощью имён, каждое из которых имеет формат:
<имя объекта> . <имя класса> :: <имя элемента>
Имя класса с операцией уточнения области действия ‘::’ обычно может быть опущено, и чаще всего для доступа к данным конкретного объекта заданного класса (как и в случае структур) используется уточнённое имя:
<имя объекта> . <имя элемента>
При этом возможности те же, что и при работе с элементами структур. Например, можно явно присвоить значения элементам объектов класса complex:
x1. re=dim[8]. re=1.24;
x1. im=2.3; dim[8]. im=0.0;
Уточнённое имя принадлежит классу (т.е. компонентной) функции
<имя объекта> . <обращение к компонентной функции>
обеспечивает вызов компонентов функции класса для обработки данных именно того объекта, имя которого использовано в уточнённом имени. Например, можно таким образом определить значения компонентных данных для определённых выше объектов класса complex:
x1 . def( ); // Параметры выбираются по умолчанию: re==0.0, im==0.0
x2 . def( 4.3,20.0); // Комплексное число 4.3+i*20.0
C помощью принадлежащей классу complex функции disp( ) можно вывести на экран значения компонентных данных любого из объектов класса. Например, следующий вызов принадлежащей классу complex функции:
x2 . disp( );
приведёт к печати
real=4.3 , imag=20.0;
Другой способ доступа к элементам объекта некоторого класса предусматривают явное использование указателя на объект класса и операции косвенного выбора компонента ( ' –>') :
<указатель на объект класса> -> <имя класса>
Определив, как сделано выше, указатель point, адресующий объект D класса complex, можно следующим образом присвоить значения данного объекта D:
point -> re=2.3; // Присваивание значения элементу области D
point -> im=6.1; // Присваивание значения элементу области D
Указатель на объект класса позволяет вызывать принадлежащие классу функции для обработки данных того объекта, который адресуется указателями. Формат вызова функции:
<указатель на объект класса> -> <обращение к компонентной функции>
Например, вызвать компонентную функцию disp( ) для данных объекта D позволяет выражение
point -> disp( );
В качестве второго примера рассмотрим класс, описывающий товары на складе магазина. Компонентами класса будут:
· Название товара
· Оптовая (закупочная) цена
· Розничная (торговая) наценка
· Функция ввода данных о товаре
· Функция печати (вывода на дисплей) сведений о товаре с указанием розничной цены.
Определение класса:
// GOODS.H - класс «товары на складе магазина»
#include “iostream.h”
class goods
{
char name [40];
float price;
static int percent; // Торговая наценка, в %
// Компонентные функции
void input ( ) // Ввод сведений о товаре
{
cout << «Наименование товара: »; cin >> name;
cout << «Закупочная цена: »; cin >> price;
}
void disp( ) // Вывод данных о продаваемом товаре
{
cout << « \n» << name;
cout << «, розничная цена: »;
cout << long ( price * ( 1.0 + goods : : percent *0.01));
}
};
Торговая наценка определена как статический компонент класса. Статические компоненты классов не «дублируются» при создании объектов класса, то есть каждый статический компонент существует в единственном экземпляре. Доступ к статическому компоненту возможен только после его инициализации. Для инициализации используется конструкция:
<тип> <имя класса> : : <имя компонента> <инициализатор>;
В нашем примере может быть такой вариант:
int goods : : percent=12;
Это предложение должно быть размещено в глобальной области после определения класса. Только при инициализации статический компонент класса получает память и становится доступным. Для обращения к статическому компоненту используется квалифицированное имя:
<имя класса> : : <имя компонента>
Кроме того, статический компонент доступен «через» имя конкретного объекта:
<имя объекта>.<имя класса> : : <имя компонента>
либо
<имя объекта>. <имя компонента>
Дата добавления: 2015-08-08; просмотров: 772;