Počítače a programování 2 pro obor EST BPC2E PŘEDNÁŠKA 3 OSNOVA: a) Úvod do OOP b) Třídy bez metod c) Třídy s metodami d) Konstruktory a destruktory e) Metody const f) Knihovní třídy g) Třídy ve třídě Jiří Šebesta Ústav radioelektroniky, FEKT VUT v Brně

Úvod do OOP (1/4) Program - model popisující reálný problém – abstrakce problému a jeho popis algoritmem nad daty pomocí programovacího jazyka ANSI - C - procedurální programování: nad daty (proměnné, vstupy ze souboru z klávesnice) provádíme sled procedur na základě definice algoritmu s využitím konstrukcí s klíčovými slovy jazyka C a s využitím funkcí - data oddělena od funkcí: problém specifikace obecného řešení problému, které je více svázaný s reálným pohledem na svět (obecně platí, že s určitou skupinou dat, lze provádět jen určité děje, nelze například dva řetěze dělit apod.)

Úvod do OOP (2/4) Objektově orientované programování OOP pro snadnější abstrakci reálných úloh (přehledný a jedno-značný popis reálného problému programem – modelem) propojuje data a funkce (operace) nad nimi - základním prvkem programu je objekt – má dané charakte-ristiky a dané metody (funkce nebo procedury, které lze s daným objektem provádět) - objektem může být nějaký grafický komponent na obrazovce (např. tlačítko “Cancel”, které můžeme definovat souborem proměnných atributů jako je např. velikost tlačítka, barva, umístění na obrazovce, atribut jestli můžu taháním myší měnit jeho velikost apod., má ale také možné definované funkce – akce – na které je třeba reagovat, např. kliknutí na tlačítko myší, přejetí kurzorem přes tlačítko, reakce na nějakou klávesovou zkratku apod.)

Úvod do OOP (3/4) - objektem může být i model nějakého reálného objektu (např. tužka, která může mít proměnné atributy jako je např. tloušťka tuhy, barva, stav – ořezaná vs. neořezaná apod., má ale také možné definované funkce – akce – tužku lze ořezat, zkrátit apod.) ZÁKLADNÍ PILÍŘE OOP: ZAPOUZDĚNÍ - deklarace třídy pro daný objekt, který spojuje (zapouzdřuje proměnné a metody) = uživatelsky definovaný typ. DĚDIČNOST – odvození nových tříd objektů od dříve deklarovaných, dědí se všechny původní atributy a metody, které se mohou modifikovat a přidávat i další nové atributy a metody (např. máme definovánu třídu zvíře, která má řadu atributů a metod a mohu z ní odvodit třídu savec s dalšími vlastnostmi typickými pro savce – např. doba kojení)

Úvod do OOP (4/4) POLYMORFISMUS (MNOHOTVAROST) - funkce tříd se mohou chovat různě (mít více forem), polymorfismus umožňuje objektům volání jedné metody se stejným jménem, ale s jinou implementací Základní model objektu v OOP deklaruje TŘÍDA = deklarace proměnných (atributů) + deklarace metod pro daný objekt a dané proměnné objektu - vychází ze struktury (ANSI C) a je doplněna o metody (funkce nad daty třídy) - reprezentuje sbírku proměnných (obvykle různých typů) v kom-binaci se sadou souvisejících funkcí

Třídy bez metod (1/5) Deklarace vlastní třídy Person (bez metod) #include <iostream> class Person // own class declaration { public: unsigned int ID; // public members (variables) unsigned int age; // of class }; Třída Person obsahuje dva členy (proměnné) ID a age, které definují identifikační číslo osoby a její věk. Klíčové slovo public označuje, že všechny položky (členy), tedy ID i age, jsou veřejně přístupné. Třída Person neobsahuje žádné metody (funkce).

Třídy bez metod (2/5) K veřejně přístupným položkám dané třídy se přistupuje podobně jako u struktury. Níže je deklarován nový objekt Eva třídy Person. Členy objektu Eva, konkrétně ID a age jsou nastaveny nezávisle ve funkci main(). int main() { Person Eva; //new object of class Person Eva.ID = 1; //value to public variable assignment Eva.age = 30; std::cout << "Person with ID " << Eva.ID << " is "; std::cout << Eva.age << " years old." << endl; //out to std return 0; } Příklad: BPC2E_Ex101.cpp

Třídy bez metod (3/5) Klíčové slovo public: definuje proměnné třídy, které jsou veřejně přístupné – lze je měnit kdykoli vně objektu Klíčové slovo private: definuje proměnné třídy, které nejsou veřejně přístupné – lze je měnit jen metodami dané třídy std je standardní třída cout je standarní výstup cin je standardní vstup std::cout je definice standardního výstupu >> je operátor přesměrování endl = end of line

Třídy bez metod (4/5) V C++ lze definovat jmenný prostor namespace pro který jsou používány jména metod a proměnných dané třídy definované v namespace pomocí klíčového slova using. … using namespace std; //namespace std is set for using int main() { Person Eva; //new object of class Person Eva.ID = 1; //value to public variable assignment Eva.age = 30; cout << "Person with ID " << Eva.ID << " is "; cout << Eva.age << " years old." << endl; return 0; } Příklad: BPC2E_Ex102.cpp

Třídy bez metod (5/5) Privátní proměnná třídy – nemá standardní přístup mimo třídu class Person // own class declaration { public: unsigned int ID; // public members of class private: // private members of class unsigned int age; }; int main() Person Eva; // new object of class Person Eva.age = 30; // error – age is private member std::cout << Eva.age; //error – age is private return 0; } Příklad: BPC2E_Ex103.cpp

Třídy s metodami (1/4) Deklarace metod třídy #include <iostream> class Person //own class declaration { public: // public members (variables) of class void SetAge(unsigned int new_age); // methods are unsigned int GetAge(); // public void IncAge(); unsigned int ID; //variable private: //private members of class unsigned int age; }; Metody (funkce) třídy jsou vždy veřejné proto, aby mohly být využívány hlavním programem.

Třídy s metodami (2/4) Definice metod třídy void Person::SetAge(unsigned int new_age) { //set new age of object age = new_age; } unsigned int Person::GetAge() { //get and return age of object return age; void Person::IncAge() { //increment age by one age++;

Třídy s metodami (3/4) S výhodou lze omezit rozsah privátní proměnné úpravou přístupové metody. Možnost přesného vymezení rozsahu nebo výčtu (enumerativní typy proměnných) je další výhodou OOP. void Person::SetAge(unsigned int new_age) { //set new age of object - max. 150 years if(new_age <= 150) age = new_age; } void Person::IncAge() { //increment age by one - max. 150 years if(age < 150) age++;

Třídy s metodami (4/4) Použití metod třídy (veřejné) k přístupu do privátní proměnné třídy using namespace std; int main() { unsigned int a; Person Eva; //new object of class Person cout << "Insert Eva's age: "; cin >> a; //chars from cin to var. a as number Eva.SetAge(a); //calling method to set Eva's age Eva.IncAge(); //incrementation of Eva's age Eva.IncAge(); //incrementation of Eva's age cout << endl << "Eva is "; cout << Eva.GetAge() << " years old"; return 0; } Příklad: BPC2E_Ex104.cpp

Konstruktory a destruktory (1/4) Při deklaraci třídy lze deklarovat speciální metody, které se provedou při vytvoření objektu nebo při odstranění objektu: KONSTRUKTOR – metoda, která se volá při vytváření objektu DESTRUKTOR – metoda, která se volá při odstraňování objektu #include <iostream> class Person //own class declaration { public: // public members (variables) of class Person(unsigned int ini_age);//constructor with // age initialization ~Person(); //destructor

Konstruktory a destruktory (2/4) void SetAge(unsigned int new_age); //methods unsigned int GetAge(); void IncAge(); unsigned int ID; //variable private: //private members of class unsigned int age; }; Konstruktor má stejné jméno jako příslušná třída, destruktor má stejné jméno jako příslušný konstruktor (třída) + znak ~ (tilda) před jménem.

Konstruktory a destruktory (3/4) Definice konstruktoru / destruktoru, pokud není definováno je konstruktor a destruktor prázdný – jen se provede instance (vytvoření) prázdného objektu (konstruktor) a řádné odstranění objektu a uvolnění z paměti (destruktor). Person::Person(unsigned int ini_age) { //constructor definition if(ini_age <= 150) age = ini_age; else age = 150; } Person::~Person() { //destructor definition – no action definition // empty destructor

Konstruktory a destruktory (4/4) Vytvoření objektu (instance třídy) pomocí definovaného konstruk-toru using namespace std; int main() { Person Eva(30);//new object using constructor Eva.IncAge(); //incrementation of Eva's age cout << "Eva is "; cout << Eva.GetAge() << " years old"; return 0; } Parametry konstruktoru se předají příslušným proměnným objektu, lze tak provést prvotní inicializaci proměnných objektu Příklad: BPC2E_Ex105.cpp

Metody const (1/1) Nedovolený zásah do privátní proměnné – ochrana přístupu k privátním proměnným metodou pomocí klíčového slova const #include <iostream> class Person //own class declaration { unsigned int GetAge() const; //const methods //cannot change variable members of class }; //definition of methods ... unsigned int Person::GetAge() const return age++; //error – changing variable member } Příklad: BPC2E_Ex106.cpp

Knihovní třídy (1/3) Knihovní deklarace vlastní třídy #ifndef PERSON_HPP_INCLUDED #define PERSON_HPP_INCLUDED #include <iostream> class Person //Person class declaration { public: //public members (variables) of class Person(unsigned int ini_age); //constructor ~Person(); //destructor …

Knihovní třídy (2/3) Použití řádkových metod (inline methods) … //row definitions of methods void SetAge(unsigned int new_age) {age = new_age;} unsigned int GetAge() {return age;} void IncAge() {age++;} private: //private members of class unsigned int age; }; #endif // PERSON_HPP_INCLUDED Příklad: person.hpp

Knihovní třídy (3/3) Instance třídy (vytvoření objektu) z knihovní deklarace třídy #include "person.hpp" //header file include Person::Person(unsigned int ini_age) { //constructor definition age = ini_age; } Person::~Person() { //destructor definition int main() { Person Eva(30); //new object using constructor ... return 0; Příklad: BPC2E_Ex107.cpp + person.hpp

Třídy ve třídě (1/6) Příklad: Třída pro popis objektu typu obdélník s využitím jednoduché třídy pro bod. Deklarace třídy pro bod - dvě souřadnice + přístupové metody #ifndef RECT_HPP_INCLUDED #define RECT_HPP_INCLUDED #include <iostream> class Point //coordinates x,y { public: void SetX(int x) {X = x;} void SetY(int y) {Y = y;} int GetX()const {return X;} int GetY()const {return Y;} private: int X; int Y; };

Třídy ve třídě (2/6) Deklarace třídy pro obdélník: 4x proměnná typu int 4x proměnná typu Point class Rect //rectangle class { public: Rect (int top, int left, int bottom, int right); ~Rect () {} int GetTop() const {return Top;} int GetLeft() const {return Left;} int GetBottom() const {return Bottom;} int GetRight() const {return Right;} Point GetTopLeft() const {return TopLeft;} Point GetTopRight() const {return TopRight;} Point GetBottomLeft() const {return BottomLeft;} Point GetBottomRight() const {return BottomRight;}

Třídy ve třídě (3/6) Metody: přístupové metody k privátním proměnným + výpočet plochy void SetTopLeft(Point pos) {TopLeft = pos;} void SetTopRight(Point pos) {TopRight = pos;} void SetBottomLeft(Point pos) {BottomLeft = pos;} void SetBottomRight(Point pos) {BottomRight = pos;} void SetTop(int top) {Top = top;} void SetLeft(int left) {Left = left;} void SetBottom(int bottom) {Bottom = bottom;} void SetRight(int right) {Right = right;} int GetArea() const;

Třídy ve třídě (4/6) private: Point TopLeft; Point TopRight; Point BottomLeft; Point BottomRight; int Top; int Left; int Bottom; int Right; }; #endif // RECT_HPP_INCLUDED Deklarace třídy Rect uložena jako knihovna v souboru rect.hpp Příklad: rect.hpp

Třídy ve třídě (5/6) Konstruktor pro třídu Rect – inicializace pomocí int parametrů, Point proměnné lze přímo dovodit a naplnit #include "rect.hpp" Rect::Rect(int top, int left, int bottom, int right) { Top = top; Left = left; Bottom = bottom; Right = right; TopLeft.SetX(left); TopLeft.SetY(top); TopRight.SetX(right); TopRight.SetY(top); BottomLeft.SetX(left); BottomLeft.SetY(bottom); BottomRight.SetX(right); BottomRight.SetY(bottom); }

Třídy ve třídě (6/6) Definice pro výpočet plochy obdélníku a main() int Rect::GetArea() const { int w = Right - Left; int h = Top - Bottom; return (w * h); } int main() Rect my_rect(10, 5, 0, 25); //new object int S = my_rect.GetArea(); std::cout << "Area: " << S << "\n"; return 0; Příklad: BPC2E_Ex108.cpp + rect.hpp

Téma následující přednášky DĚKUJI ZA POZORNOST Téma následující přednášky OOP: přetížení členských funkcí, dědičnost