Углубленное изучение отдельного раздела: стандартные классы С++

Размещено на http://www.allbest.ru/

УЗБЕКСКОЕ АГЕНТСТВО СВЯЗИ И ИНФОРМАТИЗАЦИИ

ТАШКЕНТСКИЙ УНИВЕРСИТЕТ ИНФОРМАЦИОННЫХ ТЕХНОЛОГИЙ

Кафедра «Информатики и графики»

КУРСОВАЯ РАБОТА

на тему:

«УГЛУБЛЕННОЕ ИЗУЧЕНИЕ ОТДЕЛЬНОГО РАЗДЕЛА: СТАНДАРТНЫЕ КЛАССЫ С++»

Выполнила:

Студентка группы 252-10ИТр.

Буланик Анна

Приняла:

Идиатуллина Э.М.

Ташкент 2011

Оглавление

Теоретическая часть

Классы в С++

Определение

Использование класса

Управление доступом к классу

Пример реализации и использования класса

Стандартные классы: vector, string

Литература

ТЕОРЕТИЧЕСКАЯ ЧАСТЬ

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

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

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

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

Каждый член класса может иметь свой уровень доступа (access control level), который определяет участки кода, из которых можно будет обращаться к этому члену. Большинство объектно-ориентированных языков программирования поддерживают следующие уровни доступа:

§ private (внутренний член класса) - обращение к членам класса, определённым с этим уровнем доступа возможен только из методов этого же класса. Никакие наследники класса уже не имеют доступа к этим членам.

§ protected (внутренний член иерархии классов) - обращение к членам класса, определённым с таким уровнем доступа возможен из методов этого класса и из методов классов-потомков.

§ public (открытый член класса) - доступ к членам класса, определённым с этим уровнем доступа, свободен из любого кода.

Непосредственно с классами связаны три наиболее важных механизма объектно-ориентированного программирования:

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

§ Инкапсуляция - это сокрытие полей и методов класса, доступ к которым непосредственно извне нежелателен. При этом для взаимодействия с инкапсулированными членами класса предоставляется интерфейс и только через этот интерфейс можно взаимодействовать с ними.

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

Класс, как правило, имеет также специальные методы:

§ Конструктор- отличается от прочих методов тем, что не имеет определённого типа возвращаемых данных (явным образом) и не наследуется. Конструктор, как правило, имеет имя одинаковое с именем класса, в котором объявляется. Собственно задача конструктора состоит в инициализации членов экземпляра класса.

§ Деструктор- служит для деинициализации экземпляра класса и освобождения занимаемой им памяти.

КЛАССЫ В С++

Классы в С++ являются главным инструментальным средством объектно-ориентированного программирования. Это и является основным отличием C++ от С.

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

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

Виды конструкторов:

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

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

3. Конструктор преобразования

4. Виртуальный конструктор

Например:

class Complex

{

public:

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

// (в данном случае является также и конструктором преобразования)

Complex(double i_re = 0, double i_im = 0)

: re(i_re), im(i_im)

{}

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

Complex(const Complex &obj)

{

re = obj.re;

im = obj.im;

}

private:

double re, im;

};

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

Конструктор, аргументом которого является ссылка на объект того же класса. Применяется в C++ для передачи объектов в функции по значению.

Конструктор копирования в основном необходим, когда объект имеет указатели на объекты выделенные в куче. Если программист не создаёт конструктор копирования, то компилятор создаст неявный конструктор копирования, который копирует указатели как есть, то есть фактическое копирование данных не происходит и два объекта ссылаются на одни и те же данные в куче. Соответственно попытка изменения «копии» повредит оригинал, а вызов деструктора для одного из этих объектов при последующем использовании другого приведёт к обращению в область памяти, уже не принадлежащую программе.

3. Аргумент должен передаваться именно по ссылке, а не по значению. Это вытекает из коллизии: при передаче объекта по значению (в частности, для вызова конструктора) требуется скопировать объект. Но для того, чтобы скопировать объект, необходимо вызвать конструктор копирования.

4. Конструктор, принимающий один аргумент. Задаёт преобразование типа своего аргумента в тип конструктора. Такое преобразование типа неявно применяется только если оно уникально.

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

«Виртуальными конструкторами» называют похожий, но другой механизм, присутствующий в некоторых языках -- например, он есть в Delphi, но нет в C++ и Java. Этот механизм позволяет создать объект любого заранее неизвестного класса при двух условиях:

· этот класс является потомком некоего наперёд заданного класса (в данном примере это класс TVehicle);

· на всём пути наследования от базового класса к создаваемому цепочка переопределения не обрывалась. При переопределении виртуального метода синтаксис Delphi требует ключевое слово overload, чтобы старая и новая функции с разными сигнатурами могли сосуществовать, override для переопределения функции либо reintroduce для задания новой функции с тем же именем -- последнее недопустимо.

Например:

type

TVehicle = class

constructor Create; virtual;

end;

TAutomobile = class (TVehicle)

constructor Create; override;

end;

TMotorcycle = class (TVehicle)

constructor Create; override;

end;

TMoped = class (TMotorcycle) // обрываем цепочку переопределения - заводим новый Create

constructor Create(x : integer); reintroduce;

end;

В языке вводится так называемый классовый тип. Этот тип в качестве значения может принимать название любого класса, производного от TVehicle.

type

CVehicle = class of TVehicle;

Такой механизм позволяет создавать объекты любого заранее неизвестного класса, производного от TVehicle.

var

cv : CVehicle;

v : TVehicle;

cv := TAutomobile;

v := cv.Create;

Заметьте, что код

cv := TMoped;

v := cv.Create;

- является некорректным -- директива reintroduce разорвала цепочку переопределения виртуального метода, поэтому будет вызван конструктор TMotorcycle.Create (а значит, будет создан мотоцикл, а не мопед!)

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

class ClassWithConstructor {

public:

/* Инициализация внутреннего объекта с помощью конструктора */

ClassWithConstructor(float parameter): object(parameter) {}/* вызов конструктора AnotherClass(float); */

private:

AnotherClass object;

};

ОПРЕДЕЛЕНИЕ

класс конструктор шаблон доступ

Приведем пример определения класса:

class TCounter {

long count; // данные класса

public:

long GetValue(); //функции-члены класса

void SetValue(long);

};

Определение класса начинается с ключевого слова class за которым следует имя класса. Имя класса может иметь до 32 символов, причем различаются строчные и прописные буквы. Открывающая и закрывающая фигурные скобки определяют тело класса, в которое включено описание данных и функций класса. Заканчивается описание класса символом «;». Класс имеет столько переменных (данных), сколько необходимо. Переменные могут быть любого типа, включая другие классы, указатели на классы и указатели на динамически распределяемые объекты. Переменные объявленные внутри класса имеют область видимости класса, т.е. от точки объявления переменной до конца класса.

Определение функций - членов класса.

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

// установить значение счетчика

void TCounter::SetValue(long val) {

count = val;

}

//получить значение счетчика

long TCounter::GetValue() { return count; }

В приведенной реализации запись TCounter:: сообщает компилятору, что реализация функций принадлежит классу TCounter. Символ :: является операцией определения области действия.

“Друзья”

Спецификаторы доступа позволяют указать, к каким элементам класса могут обращаться функции, в него не входящие. Однако могут быть случаи, когда целесообразно разрешить некоторому классу или функции обращаться к закрытым или защищенным элементам данного класса. Это можно сделать с помощью ключевого слова friend.

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

Вот пример объявления Друзей класса:

class SomeClass (

friend class AnotherClass;

friend void regularFunc (int);

friend void OtherClass::MemFunc(double);

//...

};

Следует иметь в виду такие правила:

Дружественность не обратима: если А объявляет В другом, это не значит, что А будет другом В. Дружба “даруется”, но не “присваивается”.

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

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

ИСПОЛЬЗОВАНИЕ КЛАССА

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

void main()

{

TCounter cnt; //создание объекта cnt типа TCounter

cnt.SetValue(10); //вызов метода для инициализации

//определение и инициализация указателя на объект

TCounter* p = &cnt;

int i = p->GetValue();//использование указателя

//определение ссылки

TCounter& Rp = &cnt;

i = Rp.GetValue(); //использование ссылки

//Определение массива указателей

TCounter* m[10];

//Создание и инициализация объектов

for (int k = 0; k < 10; k++) {

m[k] = new TCounter;

m[k]->SetValue(0);

}

//Освобождение памяти

for (i = 0; i < 10; i++) delete m[i];

}

УПРАВЛЕНИЕ ДОСТУПОМ К КЛАССУ

Для ограничения уровня доступа к данным и функциям-членам класса в С++ существуют три ключевых слова private: (частный), protected: (защищенный), public: (общедоступный), задающие уровни доступа в классе. Каждый раздел в классе начинается с одного из приведенных слов. Если ни одно из ключевых слов не использовалось, то все объявления в классе считаются частными. Разделы с разными привилегиями доступа могут появляться в любом порядке и в любом количестве. Рассмотрим пример.

class Example {

int x1; // частные по умолчанию

int f1();

protected:

int x2; // защищенные

int f2();

private:

int x3; // опять частные

int f3();

public:

int x4; // общедоступные

inf f4();

};

Частные члены класса

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

class TPrivateClass {

int value;

int GetValue();

};

int TPrivateClass::GetValue() {

return value; //доступ разрешен

}

void main() {

TPrivateClass cl; //создание объекта

int i = cl.value; //ошибка! Нет доступа

i = cl.GetValue();//ошибка! Нет доступа

}

Защищенные члены класса

Члены и функции объявленные в защищенном (protected) разделе класса доступны только для функций производных классов. Обычно в этом возникает необходимость тогда, когда разрабатываемый класс является базовым классом для других классов. В этом случае он ограничивает доступ к данным внешним пользователям и разрешает доступ для классов наследников. Рассмотрим пример иерархии объектов:

class A {

protected:

int val;

};

class B: public A { //наследуется от A

public:

void fb();

};

void B::fb() { val = 0; } //доступ разрешен

class C:public B { //наследуется от B

public:

void fc();

};

void C::fc() {val = 10;} //доступ разрешен

В данном примере приведена иерархия классов A->B->C. Свойство защищенности распространяется вниз по иерархии до тех пор пока производный класс объявляет свой базовый общедоступным (public). При этом любые функции-члены в классах C и B имеют доступ к члену данных val базового класса. Если функция-член производного класса в качестве входного параметра имеет указатель или ссылку на объект базового класса, то правила становятся другими. Модифицируем класс C следующим образом:

class C:public B {

public:

void fc(A&); //Входной параметр ссылка на базовый класс

};

void C::fc(A& a) {

val = 10; //доступ разрешен

a.val = 10; //ошибка! нарушение прав доступа

}

Общедоступные члены класса

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

ПРИМЕР РЕАЛИЗАЦИИ И ИСПОЛЬЗОВАНИЯ КЛАССА

Передо мной поставлена следующая задача:

использовать графические средства компилятора Borland C 3.1.

Для этого был реализован класс Car (машина), с внедненными в него публичными методами draw(), clear() и run().

Метод draw() - отвечает за рисование (прорисовку) машины на экране.

Метод clear() - отвечает за удаление машины с экрана.

Метод run() - отвечает за движение машины на экране, по заданным координатам.

Программа

#include <iostream.h>

#include <conio.h>

#include <DOS.h>

#include <stdlib.h>

#include <graphics.h>

#include <stdio.h>

// Класс - Автомобиль

class Car

{

// Направление движения (право-лево, верх-низ)

int dx,dy;

int bkcolor;

// Рисует машину направленную вперёд

void draw_forward()

{

setcolor(WHITE);

line(x,y,x+80,y);

line(x,y,x,y+50);

line(x+80,y,x+80,y+50);

line(x,y+50,x+10,y+50);

line(x+30,y+50,x+50,y+50);

line(x+70,y+50,x+80,y+50);

arc(x+20,y+50,0,180,10);

arc(x+60,y+50,0,180,10);

rectangle(x+80,y+40,x+90,y+45);

line(x+90,y+10,x+90,y+50);

arc(x+90,y+50,0,90,40);

line(x+90,y+50,x+100,y+50);

line(x+120,y+50,x+130,y+50);

arc(x+110,y+50,0,180,10);

line(x+95,y+15,x+95,y+35);

line(x+95,y+35,x+115,y+35);

arc(x+95,y+35,0,90,20);

setfillstyle(1,bkcolor);

floodfill(x+10,y+10,WHITE);

setfillstyle(1,BROWN);

floodfill(x+105,y+15,WHITE);

circle(x+110,y+50,8);

circle(x+20,y+50,8);

circle(x+60,y+50,8);

setfillstyle(1,RED);

floodfill(x+115,y+50,WHITE);

floodfill(x+25,y+50,WHITE);

floodfill(x+65,y+50,WHITE);

outtextxy(x+25,y+20,"ANNA252-10");

}

// Рисует машину направленную назад

void draw_backward()

{

setcolor(WHITE);

line(x,y,x-80,y);

line(x,y,x,y+50);

line(x-80,y,x-80,y+50);

line(x,y+50,x-10,y+50);

line(x-30,y+50,x-50,y+50);

line(x-70,y+50,x-80,y+50);

arc(x-20,y+50,0,180,10);

arc(x-60,y+50,0,180,10);

rectangle(x-80,y+40,x-90,y+45);

line(x-90,y+10,x-90,y+50);

arc(x-90,y+50,90,180,40);

line(x-90,y+50,x-100,y+50);

line(x-120,y+50,x-130,y+50);

arc(x-110,y+50,0,180,10);

line(x-95,y+15,x-95,y+35);

line(x-95,y+35,x-115,y+35);

arc(x-95,y+35,90,180,20);

setfillstyle(1,bkcolor);

floodfill(x-10,y+10,WHITE);

setfillstyle(1,BROWN);

floodfill(x-105,y+15,WHITE);

circle(x-110,y+50,8);

circle(x-20,y+50,8);

circle(x-60,y+50,8);

setfillstyle(1,RED);

floodfill(x-115,y+50,WHITE);

floodfill(x-25,y+50,WHITE);

floodfill(x-65,y+50,WHITE);

outtextxy(x-55,y+20,"ANNA252-10");

}

public:

// координаты автомобиля

int x,y;

Car(int x_, int y_, int dx_, int dy_)

{

dx=dx_;

dy=dy_;

x=x_;

y=y_;

bkcolor=random(7)+1;

}

~Car(){}

// Рисуем машину

void draw()

{

if (dx==1) draw_forward();

else draw_backward();

}

// Удаляем машину с экрана

void clear()

{

setfillstyle(1,BLACK);

bar(x,y,x+130*dx,y+60);

}

// Движение машины

void run()

{

if ((x>=getmaxx())||(x<=0)) dx=-dx;

if ((y>=getmaxy())||(y<=0)) dy=-dy;

x+=5*dx;

y+=dy;

}};

// Главная программа

void main()

{

int gd=DETECT, gm;

initgraph(&gd,&gm,"");

randomize();

// Объявляем 3 экземпляра класса в разных координатах и

// с разным направлением движения

Car car = Car(getmaxx()/2,getmaxy()/2-120,1,-1);

Car car2 = Car(getmaxx()/2,getmaxy()/2+60,-1,-1);

Car car3 = Car(getmaxx()/4,getmaxy()/2,-1,1);

// Цикл движения всех экземпляров класса

while(!kbhit())

{

car.draw();

car2.draw();

car3.draw();

delay(50);

car.clear();

car2.clear();

car3.clear();

car.run();

car2.run();

car3.run();}

getch();

closegraph();

}



СТАНДАРТНЫЕ КЛАССЫ: VECTOR, STRING

STL - это библиотека стандартных шаблонов. Она содержит, например, часто встречающиеся способы организации данных - так называемые контейнеры: динамические массивы, двунаправленные списки, стеки и др. Кроме того, STL содержит множество часто встречающихся алгоритмов: сортировка (как на всем множестве, так и на части его), нахождение минимального и максимального значений и др. Каждый такой алгоритм работает с разными типами контейнеров. Т. е. вы, например, можете использовать один и тот же алгоритм сортировки как для динамического массива, так и для стека.

Класс vector

Вектор (vector) напоминает нам массив, только он способен расти до произвольного размера, поддерживает информацию о размере. Как и массив к вектору можно обратить воспользовавшись операцией индексирования []. Вот характеристики:

· Доступ к данных с одинаковой скоростью

· Вставка приводит к перемещению элементов

· При расширении данные копируются в другой блок

Как видите вектор оптимален для получения информации, но при большом количестве вставок лучше воспользоваться другими контейнерами, например, списками. Проблема в том, что физически вектор распологается в непрерывной памяти. На C это реализовывали функциями malloc.

Для работы с вектором необходимо подключить заголовочный файл:

#include "vector"

Объявить рабочую область:

using namespace std;

После этого вектор необходимо объявить, это можно сделать двумя способами:

1)vector< int > vArray1;

2)vector< int > vArray2(30);

В первом случае указывается пустой вектор, а во втором начальный размер.

Можно получать информацию о параметрах вектора:

· size() - сколько данных храниться

· capacity() - сколько может храниться до изменения размера

· max_size() - максимальный размер обычно равен наиболее большому доступному блоку памяти

Пример:

#include <iostream.h>

#include <vector>

using namespace std;

void main()

{

vector vArray1;

vector vArray2(30);

cout << "Size Vector " << vArray2.size() << endl;

cout << "Capacity Vector " << vArray2.capacity() << endl;

cout << "Max_Size Vector " << vArray2.max_size() << endl;

for (int x=1;x<5;x++)

vArray2.push_back(10);

cout << "Size Vector " << vArray2.size() << endl;

cout << "Capacity Vector " << vArray2.capacity() << endl;

cout << "Max_Size Vector " << vArray2.max_size() << endl;

}

Результат:

Size Vector 30

Capacity Vector 30

Max_Size Vector 1073741823

Size Vector 34

Capacity Vector 60

Max_Size Vector 1073741823

Press any key to continue

Как видите, Size показывает, сколько сейчас лежит в векторе чисел. В то время как capacity возвращает инициализированный размер, то есть тот размер, до которого можно добавлять данные без инициализации. Вас не удивило, что размер доступной памяти не изменился!? Это размер доступного блока, а не всей памяти поэтому он и не изменился.

Пример:

#include <iostream>

// Добавляем нужное пространство имен.

#include <vector>

using namespace std;

void main()

{

// Объявляем вектор из целых.

vector <int> k;

// Добавляем элементы в конец вектора.

k.push_back(22);

k.push_back(11);

k.push_back(4);

// Показываем все элементы вектора.

for (int i = 0; i<k.size(); i++)

{

cout<<k[i]<<"\n";

}

cout<<"***\n";

// Удаляем элемент с конца вектора.

k.pop_back();

// Показываем все элементы вектора.

for (i = 0; i<k.size(); i++)

{

cout<<k[i]<<"\n";

}

cout<<"***\n";

// Удаляем все элементы ветораю

k.clear();

// Проверяем, что вектор пуст.

if(k.empty)

{

cout<<"Vector is empty\n";

}

}

Класс string

Класс string предназначен для работы со строками.

Для работы со string необходимо подключить заголовочный файл:

#include "string"

Объявить рабочую область:

using namespace std;

Пример использования:

#include <iostream>

#include <string>

using namespace std;

void main(){

string s0 = "abcde";

string s1 = " fg";

// Конкатенация строк.

string s = s0 + s1;

cout<<s<<"\n";

// Получаем символ на определенном месте.

char ch0 = s0.at(1);

cout<<ch0<<"\n";

char ch1 = s0[3];

cout<<ch1<<"\n";

// Выясняем, не пустая ли строка.

if (s0.empty()){

cout << "String is empty"<<"\n";

}

else{

cout << "String isn't empty"<<"\n";

}

// Обмен значения двух строк.

swap(s0, s1);

// Присваиваем и сравниваем 2 строки.

s1 = s0;

if(s1 == s0){

cout << "Strings are equal"<<"\n";

}

else{

cout << "Strings are not equal"<<"\n";

}

// Чтение введенной с клавиатуры строки.

getline(cin, s1);

cout<<s1;

// Получение длины строки.

cout<<s1.length();

}

Как видно, работать со строками через класс string достаточно удобно. Можно делать конкатенацию (сложение) строк с помощью обычного оператора +, можно брать символ в определенном месте строки с помощью оператора [] (или другим способом - с помощью метода at), можете использовать привычные операторы =, ==, != для присваивания и сравнения строк. Также имеются методы для получения длины строки, для выяснения, не пустая ли это строка и др. Следует обратить внимание также на весьма полезный метод getline, который позволяет прочитать строку из определенного потока (с клавиатуры в приведённом выше примере).

ЛИТЕРАТУРА

1. Страуструп Б. Язык программирования C++. Специальное издание = The C++ programming language. Special edition. -- М.: Бином-Пресс, 2007. -- 1104 с. -- ISBN 5-7989-0223-4

2. Герберт Шилдт. Полный справочник по C++ = C++: The Complete Reference. -- 4-е изд. -- М.: Вильямс, 2006. -- 800 с. -- ISBN 0-07-222680-3

3. Керниган Б., Ритчи Д. Язык программирования Си = C programming language. -- 2-е изд. -- М.: «Вильямс», 2007. -- С. 304. -- ISBN 0-13-110362-8

4. Википедия - Интернет энциклопедия. http://ru.wikipedia.org

5. Интернет Университет Информационных Технологий - http://www.intuit.ru/department/pl/cpp/

Для наглядности примера реализации и использования класса использованы графические средства компилятора BC 3.1. Мною был реализован класс Car - автомобиль, с имплементированными в него публичными методами draw(), clear() и run(), отвечающими соответственно за прорисовку машины на экране, удаление машины с экрана и движение машины.

#include <iostream.h>

#include <conio.h>

#include <DOS.h>

#include <stdlib.h>

#include <graphics.h>

#include <stdio.h>

// Класс - Автомобиль

class Car

{

// Направление движения (право-лево, верх-низ)

int dx,dy;

int bkcolor;

// Рисует машину направленную вперёд

void draw_forward()

{

setcolor(WHITE);

line(x,y,x+80,y);

line(x,y,x,y+50);

line(x+80,y,x+80,y+50);

line(x,y+50,x+10,y+50);

line(x+30,y+50,x+50,y+50);

line(x+70,y+50,x+80,y+50);

arc(x+20,y+50,0,180,10);

arc(x+60,y+50,0,180,10);

rectangle(x+80,y+40,x+90,y+45);

line(x+90,y+10,x+90,y+50);

arc(x+90,y+50,0,90,40);

line(x+90,y+50,x+100,y+50);

line(x+120,y+50,x+130,y+50);

arc(x+110,y+50,0,180,10);

line(x+95,y+15,x+95,y+35);

line(x+95,y+35,x+115,y+35);

arc(x+95,y+35,0,90,20);

setfillstyle(1,bkcolor);

floodfill(x+10,y+10,WHITE);

setfillstyle(1,BROWN);

floodfill(x+105,y+15,WHITE);

circle(x+110,y+50,8);

circle(x+20,y+50,8);

circle(x+60,y+50,8);

setfillstyle(1,RED);

floodfill(x+115,y+50,WHITE);

floodfill(x+25,y+50,WHITE);

floodfill(x+65,y+50,WHITE);

outtextxy(x+25,y+20,"TUIT");

}

// Рисует машину направленную назад

void draw_backward()

{

setcolor(WHITE);

line(x,y,x-80,y);

line(x,y,x,y+50);

line(x-80,y,x-80,y+50);

line(x,y+50,x-10,y+50);

line(x-30,y+50,x-50,y+50);

line(x-70,y+50,x-80,y+50);

arc(x-20,y+50,0,180,10);

arc(x-60,y+50,0,180,10);

rectangle(x-80,y+40,x-90,y+45);

line(x-90,y+10,x-90,y+50);

arc(x-90,y+50,90,180,40);

line(x-90,y+50,x-100,y+50);

line(x-120,y+50,x-130,y+50);

arc(x-110,y+50,0,180,10);

line(x-95,y+15,x-95,y+35);

line(x-95,y+35,x-115,y+35);

arc(x-95,y+35,90,180,20);

setfillstyle(1,bkcolor);

floodfill(x-10,y+10,WHITE);

setfillstyle(1,BROWN);

floodfill(x-105,y+15,WHITE);

circle(x-110,y+50,8);

circle(x-20,y+50,8);

circle(x-60,y+50,8);

setfillstyle(1,RED);

floodfill(x-115,y+50,WHITE);

floodfill(x-25,y+50,WHITE);

floodfill(x-65,y+50,WHITE);

outtextxy(x-55,y+20,"TUIT");

}

public:

// координаты автомобиля

int x,y;

Car(int x_, int y_, int dx_, int dy_)

{

dx=dx_;

dy=dy_;

x=x_;

y=y_;

bkcolor=random(7)+1;

}

~Car(){}

// Рисуем машину

void draw()

{

if (dx==1) draw_forward();

else draw_backward();

}

// Удаляем машину с экрана

void clear()

{

setfillstyle(1,BLACK);

bar(x,y,x+130*dx,y+60);

}

// Движение машины

void run()

{

if ((x>=getmaxx())||(x<=0)) dx=-dx;

if ((y>=getmaxy())||(y<=0)) dy=-dy;

x+=5*dx;

y+=dy;

}};

// Главная программа

void main()

{

int gd=DETECT, gm;

initgraph(&gd,&gm,"");

randomize();

// Объявляем 3 экземпляра класса в разных координатах и

// с разным направлением движения

Car car = Car(getmaxx()/2,getmaxy()/2-120,1,-1);

Car car2 = Car(getmaxx()/2,getmaxy()/2+60,-1,-1);

Car car3 = Car(getmaxx()/4,getmaxy()/2,-1,1);

// Цикл движения всех экземпляров класса

while(!kbhit())

{

car.draw();

car2.draw();

car3.draw();

delay(50);

car.clear();

car2.clear();

car3.clear();

car.run();

car2.run();

car3.run();}

getch();

closegraph();

}

Размещено на Allbest.ru