Класове и обекти

Класовете са типове дефинирани от потребителя. Всеки клас съдържа данни и набор от функции, обработващи тези данни. Данните, които са компоненти на класа, се наричат данни-елемнти, функциите, които са компоненти на класа, се наричат функции-елементи. Подобно на това, както същност от тип int се нарича променлива, то същност от потребителски дефиниран тип (клас) се нарича обект. Класовете дават възможност да се моделират явления, които имат атрибути, представени като данни-елементи, и варианти на поведение, представени като функции-елементи. Понякога функциите-елементи в езиците за обектно-ориентирано програмиране се наричат методи, те се извикват в отговор на съобщения, изпратени към обекта.
Синтаксис на дефиниция на клас:

  1. class име_на_клас
  2. {
  3.     тяло_на_клас
  4. };

Примерна дефиниция на клас:
  1. class Time
  2. {
  3.   public:
  4.     Time();
  5.     void setTime(int, int, int);
  6.     void printMilitary();
  7.     void printStandard();
  8.   private:
  9.     int hour;
  10.     int minute;
  11.     int second;
  12. };
Eтикетите public и private се наричат спецификатори за достъп до елементите. Данните-елементи и функциите-елементи декларирани след public до следващия спецификатор за достъп се наричат открити и те са достъпни при всяко обръщение от програмата към обект от класа. Данните-елементи и функциите-елементи декларирани след private до следващия спецификатор за достъп се наричат закрити и те са достъпни само за функциите-елементи от този клас. Спецификаторите за достъп завършват с ‘:’, могат да се появяват многократно в дефиницията и в произволен ред. Препоръчва се, обаче, в дефиницията на клас всеки спецификатор за достъп до елемент да се използва само веднъж, започвайки с public.
В примера функциите-елементи са открити и те представляват открит интерфейс на класа и те ще се използват за обработка на данните от този клас. Функцията елемент Time има същото име като на класа Time. Тя се нарича конструктор на този клас – това е специална функция-елемент, която инициализира данните-елементи на обект от този клас. Конструкторът на класа се извиква автоматично при създаване на обект от този клас. Обикновено класът има няколко конструктори - това се постига чрез предефиниране на функции. Целите данни елементи hour, minute, second са достъпни само от функциите-елементи на класа. Обикновено данните-елементите са в частта private, а функциите-елементи в частта public. След като класът е дефиниран, името му може да се използва за дефиниране на обекти от този клас.
Например:
Time s, a[5], *p, &d = s;

Примерна програма:
  1. #include <iostream.h>
  2. class Time
  3. {
  4.   public:
  5.     Time();
  6.     void setTime(int, int, int);
  7.     void printMilitary();
  8.     void printStandard();
  9.   private:
  10.     int hour;
  11.     int minute;
  12.     int second;
  13. };
  14. Time::Time()
  15. {
  16.   hour = minute = second = 0;
  17. }
  18.  
  19. void Time::setTime(int h, int m, int s)
  20. {
  21.   hour = (h >= 0 && h < 24) ? h : 0;
  22.   minute = (m >= 0 && m < 60) ? m : 0;
  23.   second = (s >= 0 && s < 60) ? s : 0;
  24. }
  25.  
  26. void Time::printMilitary()
  27. {
  28.   cout << (hour < 10 ? "0 ": " ") << hour << ": " << (minute < 10 ? "0 ": " ")
  29.     << minute << ": " << (second < 10 ? "0 ": " ") << second << endl;
  30. }
  31.  
  32. void Time::printStandard()
  33. {
  34.   cout << ((hour == 0 || hour == 12) ? 12 : hour % 12) << ": " << (minute < 10
  35.     ? "0 ": " ") << minute << ": " << (second < 10 ? "0 ": " ") << second << (
  36.     (hour < 12) ? " AM ": " PM ") << endl;
  37. }
  38.  
  39. void main()
  40. {
  41.   Time t; //при това дефиниране автоматично се извиква
  42.     //конструктора на класа Time
  43.   t.printMilitary();//резултат 00:00:00
  44.   t.printStandard();//резултат 12:00:00 AM
  45.   t.setTime (13, 27, 6);
  46.   t.printMilitary();//резултат 13:27:06
  47.   t.printStandard();//резултат 1:27:06 PM
  48.   t.setTime (99, 99, 99);
  49.   t.printMilitary();//резултат 00:00:00
  50.   t.printStandard();//резултат 12:00:00 AM
  51. }
  52.  
С :: се означава двуместна операция за разрешаване на област на действие. Тъй като различните класове могат да имат елементи с еднакви имена, операцията за разрешаване на област на действие привързва името на елемента към името на съответния клас. Въпреки че функция-елемент е декларирана в дефиницията на клас, тя може да бъде описана извън тази дефиниция, тя и в този случай има област на действие клас. Ако функция-елемент е описана в дефиницията на класа, тя автоматично се разглежда като вградена, т.е. inline. Функция-елемент, описана извън дефиницията на класа, може да бъде направена вградена чрез явно използване на ключовата дума inline; ще отбележим, че компилаторът може да не вгражда никакви функции. Описанието на неголеми функции-елементи в дефиницията на класа подобрява производителността, ако компилаторът ги вгражда, но не подобрява качеството на проектиране на програмното осигуряване. cout е стандартен обект, който е свързан със стандартния поток за извеждане, който най-често операционната система свързва с екрана. endl е манипулатор, можем вместо него да изведем ‘ ’ – разликата е, че манипулаторът изчиства буфера за извеждане, т.е. предизвиква незабавно извеждане на всички данни в буфера.функциите-елементи обикновено са по-къси в сравнение с функциите при процедурното програмиране. ще отбележим, че данните елементи не могат да получават начални стойности в дефиницията на класа, където са декларирани. Тези данни-елементи трябва да бъдат инициализирани чрез конструктора на класа или чрез другите функции. Обикновено функциите-елементи имат по-малко параметри, тъй като те директно могат да използват данните-елементи в съответния клас. Това намалява вероятността за грешки при обръщенията към тях.
Функция със същото име, както на класа, но започваща с ‘~’ се нарича деструктор на този клас. Деструкторът изпълнява завършващи служебни действия на всеки обект на класа, преди паметта, разпределена за този обект да бъде повторно използвана от системата. Откритите функции реализират възможностите на класа, необходими на неговите клиенти – те се наричат интерфейс на класа. Декларирането на функциите-елементи в тялото на класа и тяхното описание извън него, отделят интерфейса на класа от неговата реализация – това подпомага разработката на качествено програмно осигуряване. Клиентите на класа го използват без да знаят вътрешните детайли на неговата реализация. Ако реализацията на класа се промени, интерфейсът на класа остава непроменен и текстът на програмата на клиента не се променя – това значително опростява модификацията на програмите. Тази тенденция се задълбочава с използването на скрити данни-елементи.