Первое знакомство с ооп

Пример 1. Разработаем простейший класс для работы с двумя целыми числами. В класс включим конструктор и следующие функции: вывод двух целых чисел; вычисление их суммы; проверка, делится ли одно число на другое без остатка; изменение двух целых чисел по правилу: наименьшее число или оба, если они одинаковы, умножаем на величину par, которая передаётся как параметр функции при её вызове.

class FirstCl { // начало описания классаFirstCl

int a,b; /* поля класса, т. е. переменные */

public: /* атрибут доступа(см.§ 2) */

/* Заголовок конструктора. Это функция, которая имеет то же имя, что и класс; тип возвращаемого значения не записывается.*/

FirstCl(int x, int y);

/* Заголовки четырёх функций (методов) класса, оформленных как внешние. Они похожи на прототипы обычных самостоятельных функций, только поля класса, т. е. два целых числа, в качестве параметров не записываем */

void MyPrint(); /* Вывод целых чисел*/

int MySum(); /* Их обычное суммирование*/

/* Логическая функция, возвращающая true или false в зависимости от того, делится ли a на b без остатка (для 10 и 3 — false, 3 и 10 — false, 10 и 2 — true, 2 и 10 — false). */ bool MyTest();

void Change (int ); /* Метод, который изменяет поля класса. */

}; /* The end of class */

/* Текст внешнего конструктора. Перед именем внешнего конструктора и каждой внешней функции записываем имя класса и операцию “::” (разрешение области видимости). Она показывает, какому классу принадлежит конструктор и методы. */

FirstCl::FirstCl (int x, int y) { a=x; b=y; };

/* Тексты четырёх внешних методов. */

void FirstCl::MyPrint()

{ cout

int FirstCl::MySum() { return a+b; };

bool FirstCl::MyTest()

{ return !(a%b); } // или return !((a%b)? true : false);

void FirstCl::Change (int par)

{ if (ab) b*=par; else if (a

};

/* В головной функции создаём объект, т. е. переменную типа класс, и вызываем включённые в класс методы. */

int main()

{ FirstCl obj(10,2); // 1

obj.MyPrint(); // 2

cout

if (obj.MyTest() ) cout

else cout

obj.Change(10); // 4

cout

obj.MyPrint(); // 5

getch(); return 0; }

В строке //1 объявили объект obj и одновременно с этим вызвали конструктор, с помощью которого создаётся объект, и в класс передаются числа 10 и 2. Методы (функции) этого объекта будут выполняться для этих чисел. При объявлении объекта можно в качестве “фактических параметров” для конструктора передать не только константы, а и значения переменных:

int A,B; cinAB; FirstCl obj(A,B);

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

Метод может использовать дополнительные параметры, которые не являются полями класса. Передаём только те параметры, которые не включены в класс. У нас для функции Change таким параметром является число, на которое умножаем наименьшее из двух чисел, или оба, если они одинаковы. Тогда в скобках при вызове такого метода записываем фактические параметры. Для функции Change передаём константу 10 для параметра par.

При вызове методов класса есть аналогия с обычными самостоятельными функциями, не членами класса. Методы типа void вызываются с помощью объекта отдельно (//2, //4, //5). Вызов метода, отличного от void, записывается непосредственно в выражении, а значит, в операторе, в котором используется значение функции (см. //3).

Пример 2. Разработать класс для работы с одномерным массивом наибольшей размерности 20.

В отличие от первого примера, все функции оформим как встроенные.

#define Midsize 20

/*Определили макрос для наибольшей размерности массива */

class Clara

{ int n; /* реальная размерность массива */

float A[Midsize];

public:

/* Конструктор инициализирует одно поле — размерность массива. При этом осуществляется проверка передаваемого значения. Массив, который является вторым полем класса, определяется с помощью функции Main. */

Clara (int m) { n=m; if (nMidsize || n

// Метод для ввода массива.

void MyInp()

{ int x=1, y=whereby()+1;

for(int I=0; I

{ if (x80-10) { x=1; y++;}

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

gotoxy(x,y); cinA[i]; }

} ; // После скобки “;” не обязательна.

/* Метод для “цветного” вывода массива: числа num выводятся цветом С1, а остальные — цветом С2. */

void MyOut(int C1, int C2, float num)

{ cout

for ( int i=0; i

{ if (A[i]==num) textcolor ( C1 );

else textcolor ( C2 );

cprintf ( %10.4f, A[i] ); }

}

/* Логический (булевский) метод, возвращающий true или false в зависимости от того, найдено число t в массиве или нет */

bool Test (float t)

{ for (int i=0; i

return false; }

/* Функция (метод), которая в массиве каждое наибольшее число меняет на наименьшее число и наоборот. Кроме того, функция возвращает наибольшее и наименьшее значения. */

void MyChange ( float mx, float mn) { mx=mn=A[0];

for(int i=0; i

{ mx= A[i]mx? A[i] : mx;

mn= A[i]

for(int i=0; i

if (A[i]==mx) A[i]=mn;

else if (A[i]==mn) A[i]=mx;

} // Конец последнего метода MyChange

} ; // Конец описания класса. “;”(точка с запятой) обязательна.

/* В головной функции работаем с несколькими одномерными массивами, пока не введём в качестве размерности число 0. */

int main()

{ int N=5; float num;

do { ClArray ObArr(N); ObArr.MyInp(); // Ввод массива

while(1) /* Цикл для поиска нескольких чисел в массиве */

{ coutnum;

if (num==1000) break;

ObArr.MyOut ( 10,13, num);

// Вывели массив разным цветом

if ( ObArr.Test ( num ) ) cout

else cout

cout

float MyMx, MyMn;

/* Изменяем массив и возвращаем в функцию main наибольшее (MyMx) и наименьшее (MyMn) значения. */

ObArr.MyChange(MyMx, MyMn);

/* Вывод массива разным цветом (наибольшее значение(MyMx) и остальные). */

ObArr.MyOut(9,13,MyMx);

/* Вывод массива разным цветом (наименьшее значение(MyMn) и остальные) */

ObArr.MyOut(14, 13, MyMn);

coutN;

} while ( N);

return 0; }

Класс. Поля и методы класса

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

Класс— это сложный (структурированный, составной) тип данных, объединяющий переменные, которые называют полямикласса, и функции для работы с этими полями, которые называют методами класса. При этом методы могут только использовать поля (вывод, вычисление суммы двух чисел в прим. 1), получать их значения (ввод), преобразовывать поля (функция MyChange в прим. 2) и выполнять другие виды обработки. Классы могут быть стандартными. Их количество в современных системах резко возрастает. Есть возможность разрабатывать собственные классы.

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

class FirstCl { int a,b; …}

class FirstCl { private: int a,b; … }

одинаковы. Private означает, что поля доступны (“видны”) только в методах данного класса. Напомним, что наследование пока здесь для упрощения не учитываем. В других функциях, не принадлежащих классу, в том числе в main, эти переменные нельзя использовать ни напрямую, ни через объект данного класса. В примере 1 в main нельзя написать ни a=5, ни cout

Методы класса, как правило, записываются после ключевого слова public (общедоступный), что означает следующее. Функции класса с таким атрибутом доступа можно вызывать как из методов данного класса напрямую, без записи имени объекта (MyOut()), так и из других функций, не являющихся членами этого класса, через объект данного класса (obj.MyPrint()).

Если поля класса объявить с ключевым словом public, то их можно использовать не только в функциях данного класса, но и в других функциях, в том числе и в main. А это противоречит принципу инкапсуляции ООП. Другими словами, несмотря на использование типа class, такое программирование не является объектно-ориентированным.

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

Методы класса можно оформить одним из следующих способов:

  • внутренние (встроенные) методы (пример 2);
  • внешние методы (пример 1).

Их сравнительная характеристика такая же, как и для обычных функций.

ООП на C++ (лекция 1)

Похожие статьи:

Понравилась статья? Поделиться с друзьями:
Добавить комментарий

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!:

Adblock
detector