ПОЯСНИТЕЛЬНАЯ ЗАПИСКА
к курсовому проекту
по дисциплине Объектно-ориентированное программирование
на тему "Проектирование и разработка абстрактных типов данных средствами языка программирования C++ Builder 6/0"
Выполнил студент группы
Руководитель (нормоконтроллер)
проекта доц. каф.
Защищен
Армавир 2010 г.
Содержание задания: Создать класс wind, характеризующий ветровой режим. Класс должен содержать два поля типа int для хранения значений направления (0˚<dd<360˚) и модуля скорости ветра (V км/час). Поля объектов инициализировать конструктором по умолчанию и конструктором с двумя параметрами. Класс должен содержать константные методы вывода значений характеристик ветра в формате (dd-V), а также каждой характеристики в отдельности и метод, вычисляющий значения составляющих скорости по известным значениям модуля и направления (u=Vcos (dd), v=Vsin (dd)). Написать программу, позволяющую выводить в виде таблицы массив переменных типа wind (каждая строка - объект класса wind). Интерфейс программы построить с использованием визуальных компонентов библиотеки VCL.
Объем работы 25-30 листов.
Рекомендуемая литература:
Архангельский А.Я. Программирование в C++ Builder 6. - М.: ЗАО "Издательство БИНОМ". 2003. - 1152 с.: ил.
Иванова П.С. Объектно-ориентированное программирование: Учебник для ВУЗов. - М.: Изд. МГТУ им Н.Э. Баумана. 2001. - 320с.: ил.
Шамис В.А. Borland C++Builder 6/0 для профессионалов. - СПб.: Питер, 2003. - 798 с.: ил.
Срок выполнения проекта с
Дата выдачи задания
Руководитель проекта доцент кафедры ВЭА ____________
Задание принял студент ___________________
Реферат
Курсовая работа: 27 с., 6 рис., 2 прил., 1 прогр.
КЛАСС WIND, ОБЪЕКТ, C++BUILDER 6.
Цель работы: закрепить навыки проектирования и разработки классов; разработать абстрактный тип данных (класс), характеризующий ветровой режим, написать программу, демонстрирующую применение разработанного класса.
Задачи:
спроектировать класс wind, построить UML - диаграмму проектируемого класса,
для инициализации полей объектов использовать конструктор по умолчанию и конструктор с параметрами, организовать вывод значений характеристик ветра в формате dd-V, а также преопределенную операцию слоения),
написать программу, позволяющую выводить в виде таблицы массив переменных типа wind (каждая строка - объект класса wind).,
В результате выполнения курсовой работы
закреплены навыки построения классов и использования механизмов инкапсуляции и полиморфизма,
написан программный модуль на языке программирования C++ в среде программирования C++Buiilder 5/0 демонстрирующая работу с классом wind, разработано руководство по применению программы.
Содержание
Введение
1. Теоретические аспекты объектно-ориентированного программирования
1.1 Основные понятия объектно-ориентированного программирования
1.2 Описание класса
1.3 Описание объектов
1.4 Конструкторы
2. Предложения по решению поставленной задачи
2.1 Предметная область программирования. Ветровой режим
2.2 Атрибуты и методы класса. UML-диаграмма
2.3 Описание использованных компонентов библиотеки VCL
2.4 Проектирование пользовательского интерфейса. Объектная декомпозиция
3. Описание ПО
3.1 Руководство пользователя
3.2 Результат тестирования программы
Заключение
Приложения
Введение
Сложность современного программного обеспечения требует от разработчиков владения наиболее перспективными технологиями его создания. Одно из таких технологий на настоящий момент является объектно-ориентированное программирование (ООП). Применение ООП позволяет разрабатывать программное обеспечение повышенной сложности за счет улучшения его технологичности (лучших механизмов разделения данных, увеличения повторяемости кодов, использование стандартизованных интерфейсов пользователя и т.д.). Вместо того, чтобы рассматривать программу как набор последовательно выполняемых инструкций, в ООП программа представляется в виде совокупности объектов, обладающих сходными свойствами и набором действий, которые можно с ними производить.
Целью работы является закрепление навыков проектирования и разработки классов; разработка абстрактного типа данных (класса), характеризующего ветровой режим; разработка программы, демонстрирующей применение разработанного класса.
В первой главе приводится теоретический материал.
Во второй главе рассмотрена предметная область программирования - характеристика ветрового режима и изложены этапы проектирования класса wind, описаны классы визуальных компонентов стандартной библиотеки, использованные в ходе проектирования интерфейса пользователя.
В третьей главе приводится руководство пользователя.
Четвертая глава содержит результаты тестирования и работы программы.
Приложение содержит программный код и рисунки, с изображением окон написанной программы.
Основные понятия объектно-ориентированного программирования
Использование технологии ООП заключается в разработке отдельных, не связанных между собой классов и использовании их как необходимых программисту базовых типов данных, отсутствующих в языке. При этом общая структура программы остается традиционной. ("от функции к функции").
Объектно-ориентированное программирование (ООП) - это совокупность понятий (класс, объект, инкапсуляция, полиморфизм, наследование), приемов их использования при проектировании программ, а Си++ - инструмент этой технологии.
Строгое следование технологии ООП предполагает, что любая функция в программе представляет собой метод для объекта некоторого класса. Это не означает, что нужно вводить в программу какие попало классы ради того, чтобы написать необходимые для работы функции. Наоборот, класс должен формироваться в программе естественным образом, как только в ней возникает необходимость описания новых физических предметов или абстрактных понятий (объектов программирования). С другой стороны, каждый новый шаг в разработке алгоритма также должен представлять собой разработку нового класса на основе уже существующих. В конце концов вся программа в таком виде представляет собой объект некоторого класса с единственным методом run (выполнить). Именно этот переход (а не понятия класса и объекта, как таковые) создает психологический барьер перед программистом, осваивающим технологию ООП.
Программирование "от класса к классу" включает в себя ряд новых понятий. Прежде всего, это - инкапсуляция данных, то есть логическое связывание данных с конкретной операцией. Инкапсуляция данных означает, что данные являются не глобальными - доступными всей программе, а локальными - доступными только малой ее части. Инкапсуляция автоматически подразумевает защиту данных. Для этого в структуре class используется спецификатор раздела private, содержащий данные и методы, доступные только для самого класса. Если данные и методы содержатся в разделе public, они доступны извне класса. Раздел protected содержит данные и методы, доступные из класса и любого его производного класса. Наличие последних позволяет говорить об иерархии классов, где есть классы - родители - шаблоны для создания классов - потомков. Объекты, полученные из описания класса, называют экземплярами этого класса.
Вторым по значимости понятием является наследование. Новый, или производный класс может быть определен на основе уже имеющегося, или базового. При этом новый класс сохраняет все свойства старого: данные объекта базового класса включаются в данные объекта производного, а методы базового класса могут быть вызваны для объекта производного класса, причем они будут выполняться над данными включенного в него объекта базового класса. Иначе говоря, новый класс наследует как данные старого класса, так и методы их обработки. Если объект наследует свои свойства от одного родителя, то говорят об одиночном наследовании. Если же объект наследует атрибуты от нескольких базовых классов, то говорят о множественном наследовании. Простой пример наследования - определение структуры, отдельный член которой является ранее определенной структурой.
Третьим по значимости понятием является полиморфизм. Он основывается на возможности включения в данные объекта также и информации о методах их обработки (в виде указателей на функции). Принципиально важно, что такой объект становится "самодостаточным". Будучи доступным в некоторой точке программы, даже при отсутствии полной информации о его типе, он всегда может корректно вызвать свойственные ему методы. Полиморфной называется функция, независимо определенная в каждом из группы производных классов и имеющая в них общее имя. Полиморфная функция обладает тем свойством, что при отсутствии полной информации о том, объект какого из производных классов в данный момент обрабатывается, она тем не менее корректно вызывается в том виде, к каком она была определена для данного конкретного класса. Практический смысл полиморфизма заключается в том, что он позволяет посылать общее сообщение о сборе данных любому классу, причем и родительский класс, и классы-потомки ответят на сообщение соответствующим образом, поскольку производные классы содержат дополнительную информацию.
Описание класса
Класс является абстрактным типом данных, определяемым пользователем, и представляет собой модель реального объекта в виде данных и функций для работы с ними.
Данные класса называют полями, а функции класса - методами. Поля и методы называют элементами класса. Описание класса в первом приближении выглядит так:
сlass <имя>
{ [private:]
// описание скрытых элементов
Public:
// описание доступных элементов
}; // описание заканчивается точкой с запятой
Спецификаторы доступа private и public управляют видимостью элементов класса. Элементы, описанные после служебного слова private, видимы только внутри класса. Этот вид доступа принят в классе по умолчанию. Интерфейс класса описывается после спецификатора public. Действие любого спецификатора распространяется до следующего спецификатора или до конца класса. Можно задавать несколько секций private и public, порядок их следования значения не имеет.
Поля класса могут:
иметь любой тип, кроме типа этого же класса (но могут быть указателями или ссылками на этот класс);
быть описаны с модификатором const, при этом они инициализируются только один раз и не могут изменяться;
быть описаны с модификатором static.
Классы могут быть глобальными (объявленными вне любого блока) и локальными (объявленные внутри блока, например функции или другого класса).
Ниже приведены некоторые особенности локального класса:
внутри локального класса можно использовать типы, статические (static) и внешние (extern) переменные, внешние функции и элементы перечислений из области, в которой он описан; запрещается использовать автоматические переменные из этой области;
локальный класс не может иметь статических элементов;
методы этого класса могут быть описаны только внутри класса;
если один класс вложен в другой класс, они не имеют каких либо особых прав доступа к элементам друг друга и могут обращаться к ним только по общим правилам.
В качестве примера создадим класс, моделирующий комплексные числа, записываемые в виде а + b i, где а-действительная часть, а b-мнимая.
class Complex // комплексные числа
{
private: int a;
int ib;
public:
void setcomplex (int x, int y) // установка значений поля
{a = x; ib=y; }
void getcomplex () // ввод полей с клавиатуры
{cout<<”\n Введите действительную часть"; cin>>а;
cout<<”\n Введите мнимую часть"; cin>>ib;
}
int get_a () {return a; }
int get_ib () {return ib; }
void show () const
{ cout<<a<<" + "<<ib<<"i"; } // вывод полей на экран
};
В этом классе два скрытых поля a и ib, получить значения которых из вне можно с помощью методов get_a () и get_ib ().
Описание объектов
Конкретные переменные типа "класс" называются экземплярами класса, или объектами. Время жизни и видимость объектов зависит от вида и места их описания и подчиняется общим правилам C++.
Complex z1; // объект класса Complex с параметрами по умолчанию
Complex z2 (12,14); // объект с явной инициализацией
Complex array_of_complex [100] ; // массив объектов с параметрами по умолчанию
Complex*z = new Complex (10); // динамический объект
Complex &z3 = z1; // ссылка на объект
При создании каждого объекта выделяется память, достаточная для хранения всех его полей, и автоматически вызывается конструктор, выполняющий их инициализацию. Методы класса не тиражируются. При выходе объекта из области действия он уничтожается, при этом автоматически вызывается деструктор.
Доступ к элементам объекта аналогичен доступу к полям структуры. Для этого используется операция точка () при обращении к элементу через имя объекта и операция - > при обращении через указатель, например:
int n = z1. get_a ();
cout<<z->get_ib ();
Обратиться таким образом можно только к элементам со спецификатором public. Получить или изменит значения элементов со спецификатором private можно только через обращение к соответствующим методам.
Можно создать константный объект, значения полей которого изменять запрещается. К нему должны применяться только константные методы:
Class Complex
{
…
int get_a () const {return a; }
…
};
…
const Complex z (0,0); // константный объект
cout<<z. get_a ();
Константный метод:
Объявляется с ключевым словом const после списка параметров;
Не может изменять значений полей класса;
Может вызывать только константные методы;
Может вызываться для любых (не только константных) объектов.
Конструкторы
Конструктор предназначен для инициализации объекта и вызывается автоматически при его создании. Ниже перечислены основные свойства конструкторов.
Конструктор не возвращает значение, даже типа void. Нельзя получить указатель на конструктор.
Класс может иметь несколько конструкторов с разными параметрами для разных видов инициализации (при этом используется механизм перегрузки).
Конструктор, вызываемый без параметров, называется конструктором по умолчанию.
Параметры конструктора могут иметь любой тип, кроме этого же класса. Можно задавать значения параметров по умолчанию. Их может содержать только один из конструкторов.
Если программист не указал ни одного конструктора, компилятор создает его автоматически. Такой конструктор вызывает конструкторы по умолчанию для полей класса и конструкторы по умолчанию базовых классов. В случае, когда класс содержит константы или ссылки, при попытке создания объекта класса будет выдана ошибка, поскольку их необходимо инициализировать конкретными значениями, а конструктор по умолчанию этого делать не умеет.
Конструкторы не наследуются.
Конструкторы нельзя описывать с модификаторами const, virtual и static.
Конструкторы глобальных объектов вызываются до вызова функции main.
Локальные объекты создаются, как только становится активной область их действия.
Конструктор запускается и при создании временного объекта.
Конструктор вызывается, если в программе встретилась какая-либо из синтаксических конструкций:
имя класса имя_объекта [ (список параметров)] ;
// список параметров не должен быть пустым
имя_класса (список параметров);
// создается объект без имени (список может быть пустым)
имя класса имя_объекта = выражение;
// создается объект без имени и копируется
Примеры:
Complex z1 (10,11), z2;
Complex z = Complex (100, 200);
В первом операторе создаются два объекта. Значения не указанных параметров устанавливаются по умолчанию.
Во втором операторе создается безымянный объект, выделяется память под объект z, в которую копируется безымянный объект.
В качестве примера класса с несколькими конструкторами усовершенствуем класс Complex.
class Complex
{
private: int a;
int ib;
public: Complex (): a (0), ib (0) // конструктор без аргументов
{}
Complex (int za, int zib): a (za), ib (zib) // конструктор с двумя аргументами
{}
void show () const // вывод комплексного числа на экран
{ cout<<a<<" + "<<ib<<"i"; } };
Описание ПО
Руководство пользователя
Данная программа предназначена для демонстрации использования класса wind, характеризующего ветровой режим.
Выходные данные - массив array, значения составляющих v и u.
Системные требования: Pentium 300, 128 Мб RAM.
Запустите файл ProjectOOP. exe. Перед пользователем появится окно программы (см. рисунок 1 приложения 2), состоящее из таблицы, кнопки "Заполнить таблицу" и трех строк - "Характеристики ветра", "Составляющая скорости v", "Составляющая скорости u". Чтобы заполнить таблицу случайными значениями нажмите кнопку "Заполнить таблицу". Таблица выведет на экран значение угла, характеризующего направление ветра (первый столбец таблицы) и скорость ветра (второй столбец) - значения элементов массива переменных типа wind (см. рисунок 2 приложения 2). При выделении какой-либо ячейки таблицы в строке "Характеристики ветра" будет выведено значение характеристик ветра в виде dd-V, строки "Составляющая скорости v" и "Составляющая скорости u" выведут соответствующие значения составляющих скорости для данного элемента массива (см. рисунок 3 приложения 2).
Заключение
Проектирование и разработка классов является основой построения сложных программных комплексов. Навыки, приобретенные мною в ходе выполнения курсовой работы помогут в дальнейшем при выполнении курсовых и дипломного проекта.
В результате работы получены следующие результаты:
спроектирован класс wind, характеризующий ветровой режим,
построена UML - диаграмма класса,
написан программный модуль на языке программирования C++ в среде программирования C++Buiilder 6/0 демонстрирующий работу с классом wind,
разработано руководство по применению программы.
Приложения
Приложение 1
Текст программы
Код заголовочного файла ( kursOOP1. h):
// ---------------------------------------------------------------------------
#ifndef kursOOP1H
#define kursOOP1H
// ---------------------------------------------------------------------------
#include <Classes. hpp>
#include <Controls. hpp>
#include <StdCtrls. hpp>
#include <Forms. hpp>
#include <Grids. hpp>
// ---------------------------------------------------------------------------
class TForm1: public TForm
{
__published: // IDE-managed Components
TStringGrid *StringGrid1;
TGroupBox *GroupBox1;
TButton *Button1;
TEdit *Edit1;
TLabel *Label1;
TEdit *Edit2;
TLabel *Label2;
TEdit *Edit3;
TLabel *Label3;
void __fastcall FormCreate (TObject *Sender);
void __fastcall Button1Click (TObject *Sender);
void __fastcall StringGrid1SelectCell (TObject *Sender, int ACol,
int ARow, bool &CanSelect);
private: // User declarations
public: // User declarations
__fastcall TForm1 (TComponent* Owner);
};
// ---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
// ---------------------------------------------------------------------------
#endif
Код файла реализации (kursOOP1. cpp):
// ---------------------------------------------------------------------------
#include <vcl. h>
#pragma hdrstop
#include "kursOOP1. h"
#include <Math. h>
#include <string>
#include <stdlib. h>
#include <dstring. h>
// ---------------------------------------------------------------------------
#pragma package (smart_init)
#pragma resource "*. dfm"
class wind
{
private: int dd;
int V;
public:
wind (): dd (0),V (0) {};
wind (int dd1, int V1): dd (dd1),V (V1) {};
String ShowWind () const
{
return IntToStr (dd) +" град. - "+IntToStr (V) +" км/ч";
}
int ShowDirect () const
{return dd;
}
int ShowSpeed () const
{return V;
}
void Components (wind w,float&v,float&u) const
{v=V*sin (dd);
u=V*cos (dd); }
};
TForm1 *Form1;
const n=10;
wind array [n] ; float v,u;
// ---------------------------------------------------------------------------
__fastcall TForm1:: TForm1 (TComponent* Owner)
: TForm (Owner)
{
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: FormCreate (TObject *Sender)
{
StringGrid1->Cells [0] [0] ="Направление в град. ";
StringGrid1->Cells [1] [0] ="Скорость";
StringGrid1->RowCount=n;
for (int j=0; j<2; j++)
{for (int i=1; i<n; i++)
{StringGrid1->Cells [j] [i] =""; }}
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: Button1Click (TObject *Sender)
{
for (int i=0; i<n; i++)
{array [i] =wind (random (360),random (250));
StringGrid1->Cells [0] [i+1] =array [i]. ShowDirect ();
StringGrid1->Cells [1] [i+1] =array [i]. ShowSpeed (); }
}
// ---------------------------------------------------------------------------
void __fastcall TForm1:: StringGrid1SelectCell (TObject *Sender, int ACol,
int ARow, bool &CanSelect)
{
Edit1->Text=array [ARow-1]. ShowWind ();
array [ARow-1].components (array [ARow-1],v,u);
Edit2->Text=FloatToStr (v);
Edit3->Text=FloatToStr (u);
}
// ---------------------------------------------------------------------------
Приложение 2
Результаты тестирования
Рис.1 - окно программы
Рис.2 - вывод значений элементов массива на экран при помощи таблицы StringGrid1
Рис.3 - вывод значений характеристик ветра в виде dd-V и составляющих скорости
ПОЯСНИТЕЛЬНАЯ ЗАПИСКА
к курсовому проекту
по дисциплине Объектно-ориентированное программирование
на тему "Проектирование и разработка абстрактных типов данных средствами языка программирования C++ Builder 6/0"
Выполнил студент группы
Руководитель (нормоконтроллер)
проекта доц. каф.
Защищен
Армавир 2010 г.
Содержание задания: Создать класс wind, характеризующий ветровой режим. Класс должен содержать два поля типа int для хранения значений направления (0˚<dd<360˚) и модуля скорости ветра (V км/час). Поля объектов инициализировать конструктором по умолчанию и конструктором с двумя параметрами. Класс должен содержать константные методы вывода значений характеристик ветра в формате (dd-V), а также каждой характеристики в отдельности и метод, вычисляющий значения составляющих скорости по известным значениям модуля и направления (u=Vcos (dd), v=Vsin (dd)). Написать программу, позволяющую выводить в виде таблицы массив переменных типа wind (каждая строка - объект класса wind). Интерфейс программы построить с использованием визуальных компонентов библиотеки VCL.
Объем работы 25-30 листов.
Рекомендуемая литература:
Архангельский А.Я. Программирование в C++ Builder 6. - М.: ЗАО "Издательство БИНОМ". 2003. - 1152 с.: ил.
Иванова П.С. Объектно-ориентированное программирование: Учебник для ВУЗов. - М.: Изд. МГТУ им Н.Э. Баумана. 2001. - 320с.: ил.
Шамис В.А. Borland C++Builder 6/0 для профессионалов. - СПб.: Питер, 2003. - 798 с.: ил.
Срок выполнения проекта с
Дата выдачи задания
Руководитель проекта доцент кафедры ВЭА ____________
Задание принял студент ___________________
Реферат
Курсовая работа: 27 с., 6 рис., 2 прил., 1 прогр.
КЛАСС WIND, ОБЪЕКТ, C++BUILDER 6.
Цель работы: закрепить навыки проектирования и разработки классов; разработать абстрактный тип данных (класс), характеризующий ветровой режим, написать программу, демонстрирующую применение разработанного класса.
Задачи:
спроектировать класс wind, построить UML - диаграмму проектируемого класса,
для инициализации полей объектов использовать конструктор по умолчанию и конструктор с параметрами, организовать вывод значений характеристик ветра в формате dd-V, а также преопределенную операцию слоения),
написать программу, позволяющую выводить в виде таблицы массив переменных типа wind (каждая строка - объект класса wind).,
В результате выполнения курсовой работы
закреплены навыки построения классов и использования механизмов инкапсуляции и полиморфизма,
написан программный модуль на языке программирования C++ в среде программирования C++Buiilder 5/0 демонстрирующая работу с классом wind, разработано руководство по применению программы.
Содержание
Введение
1. Теоретические аспекты объектно-ориентированного программирования
1.1 Основные понятия объектно-ориентированного программирования
1.2 Описание класса
1.3 Описание объектов
1.4 Конструкторы
2. Предложения по решению поставленной задачи
2.1 Предметная область программирования. Ветровой режим
2.2 Атрибуты и методы класса. UML-диаграмма
2.3 Описание использованных компонентов библиотеки VCL
2.4 Проектирование пользовательского интерфейса. Объектная декомпозиция
3. Описание ПО
3.1 Руководство пользователя
3.2 Результат тестирования программы
Заключение
Приложения
Введение
Сложность современного программного обеспечения требует от разработчиков владения наиболее перспективными технологиями его создания. Одно из таких технологий на настоящий момент является объектно-ориентированное программирование (ООП). Применение ООП позволяет разрабатывать программное обеспечение повышенной сложности за счет улучшения его технологичности (лучших механизмов разделения данных, увеличения повторяемости кодов, использование стандартизованных интерфейсов пользователя и т.д.). Вместо того, чтобы рассматривать программу как набор последовательно выполняемых инструкций, в ООП программа представляется в виде совокупности объектов, обладающих сходными свойствами и набором действий, которые можно с ними производить.
Целью работы является закрепление навыков проектирования и разработки классов; разработка абстрактного типа данных (класса), характеризующего ветровой режим; разработка программы, демонстрирующей применение разработанного класса.
В первой главе приводится теоретический материал.
Во второй главе рассмотрена предметная область программирования - характеристика ветрового режима и изложены этапы проектирования класса wind, описаны классы визуальных компонентов стандартной библиотеки, использованные в ходе проектирования интерфейса пользователя.
В третьей главе приводится руководство пользователя.
Четвертая глава содержит результаты тестирования и работы программы.
Приложение содержит программный код и рисунки, с изображением окон написанной программы.
Теоретические аспекты объектно-ориентированного программирования
Основные понятия объектно-ориентированного программирования
Использование технологии ООП заключается в разработке отдельных, не связанных между собой классов и использовании их как необходимых программисту базовых типов данных, отсутствующих в языке. При этом общая структура программы остается традиционной. ("от функции к функции").
Объектно-ориентированное программирование (ООП) - это совокупность понятий (класс, объект, инкапсуляция, полиморфизм, наследование), приемов их использования при проектировании программ, а Си++ - инструмент этой технологии.
Строгое следование технологии ООП предполагает, что любая функция в программе представляет собой метод для объекта некоторого класса. Это не означает, что нужно вводить в программу какие попало классы ради того, чтобы написать необходимые для работы функции. Наоборот, класс должен формироваться в программе естественным образом, как только в ней возникает необходимость описания новых физических предметов или абстрактных понятий (объектов программирования). С другой стороны, каждый новый шаг в разработке алгоритма также должен представлять собой разработку нового класса на основе уже существующих. В конце концов вся программа в таком виде представляет собой объект некоторого класса с единственным методом run (выполнить). Именно этот переход (а не понятия класса и объекта, как таковые) создает психологический барьер перед программистом, осваивающим технологию ООП.
Программирование "от класса к классу" включает в себя ряд новых понятий. Прежде всего, это - инкапсуляция данных, то есть логическое связывание данных с конкретной операцией. Инкапсуляция данных означает, что данные являются не глобальными - доступными всей программе, а локальными - доступными только малой ее части. Инкапсуляция автоматически подразумевает защиту данных. Для этого в структуре class используется спецификатор раздела private, содержащий данные и методы, доступные только для самого класса. Если данные и методы содержатся в разделе public, они доступны извне класса. Раздел protected содержит данные и методы, доступные из класса и любого его производного класса. Наличие последних позволяет говорить об иерархии классов, где есть классы - родители - шаблоны для создания классов - потомков. Объекты, полученные из описания класса, называют экземплярами этого класса.
Вторым по значимости понятием является наследование. Новый, или производный класс может быть определен на основе уже имеющегося, или базового. При этом новый класс сохраняет все свойства старого: данные объекта базового класса включаются в данные объекта производного, а методы базового класса могут быть вызваны для объекта производного класса, причем они будут выполняться над данными включенного в него объекта базового класса. Иначе говоря, новый класс наследует как данные старого класса, так и методы их обработки. Если объект наследует свои свойства от одного родителя, то говорят об одиночном наследовании. Если же объект наследует атрибуты от нескольких базовых классов, то говорят о множественном наследовании. Простой пример наследования - определение структуры, отдельный член которой является ранее определенной структурой.
Третьим по значимости понятием является полиморфизм. Он основывается на возможности включения в данные объекта также и информации о методах их обработки (в виде указателей на функции). Принципиально важно, что такой объект становится "самодостаточным". Будучи доступным в некоторой точке программы, даже при отсутствии полной информации о его типе, он всегда может корректно вызвать свойственные ему методы. Полиморфной называется функция, независимо определенная в каждом из группы производных классов и имеющая в них общее имя. Полиморфная функция обладает тем свойством, что при отсутствии полной информации о том, объект какого из производных классов в данный момент обрабатывается, она тем не менее корректно вызывается в том виде, к каком она была определена для данного конкретного класса. Практический смысл полиморфизма заключается в том, что он позволяет посылать общее сообщение о сборе данных любому классу, причем и родительский класс, и классы-потомки ответят на сообщение соответствующим образом, поскольку производные классы содержат дополнительную информацию.
Описание класса
Класс является абстрактным типом данных, определяемым пользователем, и представляет собой модель реального объекта в виде данных и функций для работы с ними.
Данные класса называют полями, а функции класса - методами. Поля и методы называют элементами класса. Описание класса в первом приближении выглядит так:
сlass <имя>
{ [private:]
// описание скрытых элементов
Public:
// описание доступных элементов
}; // описание заканчивается точкой с запятой
Спецификаторы доступа private и public управляют видимостью элементов класса. Элементы, описанные после служебного слова private, видимы только внутри класса. Этот вид доступа принят в классе по умолчанию. Интерфейс класса описывается после спецификатора public. Действие любого спецификатора распространяется до следующего спецификатора или до конца класса. Можно задавать несколько секций private и public, порядок их следования значения не имеет.
Поля класса могут:
иметь любой тип, кроме типа этого же класса (но могут быть указателями или ссылками на этот класс);
быть описаны с модификатором const, при этом они инициализируются только один раз и не могут изменяться;
быть описаны с модификатором static.
Классы могут быть глобальными (объявленными вне любого блока) и локальными (объявленные внутри блока, например функции или другого класса).
Ниже приведены некоторые особенности локального класса:
внутри локального класса можно использовать типы, статические (static) и внешние (extern) переменные, внешние функции и элементы перечислений из области, в которой он описан; запрещается использовать автоматические переменные из этой области;
локальный класс не может иметь статических элементов;
методы этого класса могут быть описаны только внутри класса;
если один класс вложен в другой класс, они не имеют каких либо особых прав доступа к элементам друг друга и могут обращаться к ним только по общим правилам.
В качестве примера создадим класс, моделирующий комплексные числа, записываемые в виде а + b i, где а-действительная часть, а b-мнимая.
class Complex // комплексные числа
{
private: int a;
int ib;
public:
void setcomplex (int x, int y) // установка значений поля
{a = x; ib=y; }
void getcomplex () // ввод полей с клавиатуры
{cout<<”\n Введите действительную часть"; cin>>а;
cout<<”\n Введите мнимую часть"; cin>>ib;
}
int get_a () {return a; }
int get_ib () {return ib; }
void show () const
{ cout<<a<<" + "<<ib<<"i"; } // вывод полей на экран
};
В этом классе два скрытых поля a и ib, получить значения которых из вне можно с помощью методов get_a () и get_ib ().
Описание объектов
Конкретные переменные типа "класс" называются экземплярами класса, или объектами. Время жизни и видимость объектов зависит от вида и места их описания и подчиняется общим правилам C++.
Complex z1; // объект класса Complex с параметрами по умолчанию
Complex z2 (12,14); // объект с явной инициализацией
Complex array_of_complex [100] ; // массив объектов с параметрами по умолчанию
Complex*z = new Complex (10); // динамический объект
Complex &z3 = z1; // ссылка на объект
При создании каждого объекта выделяется память, достаточная для хранения всех его полей, и автоматически вызывается конструктор, выполняющий их инициализацию. Методы класса не тиражируются. При выходе объекта из области действия он уничтожается, при этом автоматически вызывается деструктор.
Доступ к элементам объекта аналогичен доступу к полям структуры. Для этого используется операция точка () при обращении к элементу через имя объекта и операция - > при обращении через указатель, например:
int n = z1. get_a ();
cout<<z->get_ib ();
Обратиться таким образом можно только к элементам со спецификатором public. Получить или изменит значения элементов со спецификатором private можно только через обращение к соответствующим методам.
Можно создать константный объект, значения полей которого изменять запрещается. К нему должны применяться только константные методы:
Class Complex
{
…
int get_a () const {return a; }
…
};
…
const Complex z (0,0); // константный объект
cout<<z. get_a ();
Константный метод:
Объявляется с ключевым словом const после списка параметров;
Не может изменять значений полей класса;
Может вызывать только константные методы;
Может вызываться для любых (не только константных) объектов.
Конструкторы
Конструктор предназначен для инициализации объекта и вызывается автоматически при его создании. Ниже перечислены основные свойства конструкторов.
Конструктор не возвращает значение, даже типа void. Нельзя получить указатель на конструктор.
Класс может иметь несколько конструкторов с разными параметрами для разных видов инициализации (при этом используется механизм перегрузки).
Конструктор, вызываемый без параметров, называется конструктором по умолчанию.
Параметры конструктора могут иметь любой тип, кроме этого же класса. Можно задавать значения параметров по умолчанию. Их может содержать только один из конструкторов.
Если программист не указал ни одного конструктора, компилятор создает его автоматически. Такой конструктор вызывает конструкторы по умолчанию для полей класса и конструкторы по умолчанию базовых классов. В случае, когда класс содержит константы или ссылки, при попытке создания объекта класса будет выдана ошибка, поскольку их необходимо инициализировать конкретными значениями, а конструктор по умолчанию этого делать не умеет.
Конструкторы не наследуются.
Конструкторы нельзя описывать с модификаторами const, virtual и static.
Конструкторы глобальных объектов вызываются до вызова функции main.
Локальные объекты создаются, как только становится активной область их действия.
Конструктор запускается и при создании временного объекта.
Конструктор вызывается, если в программе встретилась какая-либо из синтаксических конструкций:
имя класса имя_объекта [ (список параметров)] ;
// список параметров не должен быть пустым
имя_класса (список параметров);
// создается объект без имени (список может быть пустым)
имя класса имя_объекта = выражение;
// создается объект без имени и копируется
Примеры:
Complex z1 (10,11), z2;
Complex z = Complex (100, 200);
В первом операторе создаются два объекта. Значения не указанных параметров устанавливаются по умолчанию.
Во втором операторе создается безымянный объект, выделяется память под объект z, в которую копируется безымянный объект.
В качестве примера класса с несколькими конструкторами усовершенствуем класс Complex.
class Complex
{
private: int a;
int ib;
public: Complex (): a (0), ib (0) // конструктор без аргументов
{}
Complex (int za, int zib): a (za), ib (zib) // конструктор с двумя аргументами
{}
void show () const // вывод комплексного числа на экран
{ cout<<a<<" + "<<ib<<"i"; } };
Дата: 2019-04-23, просмотров: 214.
