OSNOVA: a) Úvod do OOPb) Třídy bez metod c) Třídy s metodamid) Konstruktory a destruktory e) Metody constf) Knihovní třídy g) Třídy ve tříděh) Přetížení členských funkcí i) Dědičnost tříd Jiří Šebesta Ústav radioelektroniky, FEKT VUT v Brně Počítače a programování 2 pro obor EST KPC2E TUTORIÁL 2

Úvod do OOP (1/4) 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.) Program - model popisující reálný problém – abstrakce problému a jeho popis algoritmem nad daty pomocí programovacího jazyka

Úvod do OOP (2/4) - 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.) 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)

Ú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: 1)ZAPOUZDĚNÍ - deklarace třídy pro daný objekt, který spojuje (zapouzdřuje proměnné a metody) = uživatelsky definovaný typ. 2)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) 3)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 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) 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: KPC2E_Ex95.cpp 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().

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 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 Klíčové slovo private: definuje proměnné třídy, které nejsou veřejně přístupné – lze je měnit jen metodami dané třídy

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: KPC2E_Ex96.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: KPC2E_Ex97.cpp

Třídy s metodami (1/4) Deklarace metod třídy #include 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: KPC2E_Ex98.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 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; } Příklad: KPC2E_Ex99.cpp Parametry konstruktoru se předají příslušným proměnným objektu, lze tak provést prvotní inicializaci proměnných objektu

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 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: KPC2E_Ex100.cpp

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

Knihovní třídy (2/3) … //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 Použití řádkových metod (inline methods)

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: KPC2E_Ex101.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. #ifndef RECT_HPP_INCLUDED #define RECT_HPP_INCLUDED #include 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; }; Deklarace třídy pro bod - dvě souřadnice + přístupové metody

Třídy ve třídě (2/6) 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;} Deklarace třídy pro obdélník: 4x proměnná typu int 4x proměnná typu Point

Třídy ve třídě (3/6) 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; Metody: přístupové metody k privátním proměnným + výpočet plochy

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 Příklad: rect.hpp Deklarace třídy Rect uložena jako knihovna v souboru 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: KPC2E_Ex102.cpp + rect.hpp

Přetížení členských funkcí (1/8) - definuje základní přístup k mnohotvarosti (polymorfismu) objektového programování Přetížení členských funkcí - umožňuje definovat různé parametry funkce pro různé případy jejich použití. - lze s výhodou použít i u konstruktorů s různým přístupem inicializace – objekt může být inicializován s parametry v konstruktoru nebo například bez parametrů s defaultní inicializací. - lze použít u funkce tak, aby mohla pracovat s různými typy parametrů např. double sin(double) a současně float sin(float) a podobně. Na základě typu parametrů se pak volá příslušná funkce (použito i v C).

Přetížení členských funkcí (2/8) Příklad: Doplnění třídy pro popis objektu typu obdélník s využitím jednoduché třídy pro bod z příkladu KPC2E_Ex101 o přetížení konstruktoru 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); //initialization with input parameters Rect (); //initialization by default values ~Rect () {} …

Přetížení členských funkcí (3/8) Konstruktor pro třídu Rect – inicializace pomocí vstupních int parametrů (stejné jako v hlavičkovém souboru rect.hpp k příkladu KPC2E_Ex101.cpp ) 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); }

Přetížení členských funkcí (4/8) Konstruktor pro třídu Rect bez inicializace parametrů, soukromé členské proměnné jsou naplněny defaultními hodnotami. Rect::Rect() { Top = 10;Left = 0; Bottom = 0;Right = 10; TopLeft.SetX(left); TopLeft.SetY(top); TopRight.SetX(right); TopRight.SetY(top); BottomLeft.SetX(left); BottomLeft.SetY(bottom); BottomRight.SetX(right); BottomRight.SetY(bottom); } Kompletní deklarace a definice metod třídy umístěna do rect1.hpp

Přetížení členských funkcí (5/8) Volání obou typů (přetížených) konstruktorů (defaultní a s iniciali- zací) pro vytvoření objektů typu obdélník int main() {//new object with default parameters Rect my_rect_A; int SA = my_rect_A.GetArea(); std::cout << "Area of my_rect_A: " << SA << "\n"; //new object with user parameters Rect my_rect_B(10, 5, 0, 25); int SB = my_rect_B.GetArea(); std::cout << "Area of my_rect_B: " << S << "\n"; return 0; } Příklad: KPC2E_Ex103.cpp + rect1.hpp

Přetížení členských funkcí (6/8) #include class Rect { public: Rect(int wi, int he); ~Rect(){} //two ways, how to print object rectangle: void PrintRect() const; //with parameters of given object void PrintRect(int wi, int he) const; //with reiniciated parameters private: int W; int H; }; Příklad: Přetížení metod pro kreslení obdélníku – kreslení obdélníku podle parametrů objektu – kreslení obdélníku s vlastní reinicializací parametrů

Přetížení členských funkcí (7/8) void Rect::PrintRect() const { //using params of object PrintRect(W, H); //calling print method } void Rect::PrintRect(int wi, int he) const { //using new parameters for(int i = 0; i < he; i++) { for(int j = 0; j < wi; j++) { std::cout << "\xDB"; //print char █ } std::cout << "\n"; //print new line } Definice obou metod pro vykreslení obdélníku Tiskne se plný obdélník s danou šířkou a výškou ze znaků █

Přetížení členských funkcí (8/8) int main() { Rect A(25,5); //new rectangle with initialization std::cout << "\nrectangle A:\n"; A.PrintRect(); // print rectangle with params // of object std::cout << "\nrectangle B:\n"; A.PrintRect(40,2); // print rectangle with spec. // parameters return 0; } Generování objektu obdélník s definovanými parametry a jeho následný tisk a tisk obdélníku s reinicializovanými parametry, tyto parametry se neukládají do privátních proměnných objektu W a H Příklad: KPC2E_Ex104.cpp

Dědičnost tříd (1/10) Dědičnost tříd: - je vlastnost OOP, která umožňuje vytvářet nové objekty na základě již vytvořených objektů s využitím dědění jak proměnných tak i metod původní třídy, nová metoda se označuje jako odvozená třída syntaxe: class derived_class:acces_type basic_class {declaration} Např. class dog:public mammal { }

Dědičnost tříd (2/10) Příklad: Ukázka odvození třídy Pes od třídy Savec #include using namespace std; enum RASA {ZLATY_RETRIEVER, PUDL, JEZEVCIK, OVCAK, DOBRMAN, LABRADOR}; // deklarace třídy Savec class Savec { public: Savec(); //výchozí konstruktor ~Savec(); //destruktor int VratVek() const; //přístupové metody void ZadejVek(int); int VratVahu() const; void ZadejVahu(int); …

Dědičnost tříd (3/10) … void Promluvit() const; //výkonné metody void Spat() const; protected: int Vek; //privátní proměnné int Vaha; };

Dědičnost tříd (4/10) // deklarace třídy Pes class Pes : public Savec //přebírají se všechny // metody a proměnné public a protected { public: Pes();//výchozí konstruktor ~Pes(); //destruktor RASA VratRasu() const;// přidané přístupové metody void ZadejRasu(RASA); VrtetOcasem(); // přidaná výkonná metoda protected: // přidaná nová položka, // protože je protected, RASA jehoRasa;// bude děděna dceřinnou // třídou odvozenou od třídy Pes };

Dědičnost tříd (5/10) Specifikátory přístupu: public (veřejný) – k proměnné je přístup odkudkoli, lze ji měnit např. ve funkci main() : Pes Alik; Alik.Vek = 15; private (soukromý) – k proměnné je přístup jen v rámci objektu dané třídy – pro přístup odjinud je zapotřebí použití přístupových metod protected (chráněný) - proměnná je pro danou třídu privátní avšak může se k ní přistupovat i v objektech odvozených tříd

Dědičnost tříd (6/10) Příklad: Třída Dog odvozená ze třídy Mammal a použití #include enum BREED {GOLD_RETRIEVER, POODLE, DACHSHUND, SHEEPDOG, SLEUTH, LABRADOR}; class Mammal //parent class { public: Mammal(); ~Mammal(); int GetAge() const {return Age;} void SetAge(int new_age) {Age = new_age;} int GetWeight() const {return Weight;} void SetWeight(int new_weight) {Weight = new_weight;}

Dědičnost tříd (7/10) … void Outspeak() const {std::cout << "Voice of mammal.\n";} void Sleep() const {std::cout << "Psssst. Go to sleep.\n";} protected: int Age; int Weight; };

Dědičnost tříd (8/10) class Dog : public Mammal //derived class { public: Dog(); ~Dog(); BREED GetBreed()const {return Dog_breed;} void SetBreed(BREED new_breed) {Dog_breed = new_breed;} void WagByTeil()const {std::cout << "Dog is wagging by its tail.\n";} void BegForGrub()const {std::cout << "Dog is begging for grub.\n";} private: BREED Dog_breed; }; odvozená třída Dog

Dědičnost tříd (9/10) Mammal::Mammal(): //constructor with inicialization Age(1), Weight(5) { std::cout << "Constr. of Mammal is active.\n"; } Mammal::~Mammal() { std::cout << "Destr. of Mammal is active.\n"; } Dog::Dog(): //constructor with inicialization Dog_breed(GOLD_RETRIEVER) { std::cout << "Constructor of Dog is active.\n"; } Dog::~Dog() { std::cout << "Destructor of Dog is active.\n"; }

Dědičnost tříd (10/10) int main() { Dog Fido; Fido.Outspeak(); //method from parental class Fido.WagByTeil(); Fido.BegForGrub(); std::cout << "Fido is" << Fido.GetAge() << " years old\n"; Fido.SetAge(3); std::cout << "Fido is now" << Fido.GetAge() << " years old\n"; return 0; } Příklad: KPC2E_Ex105.cpp Výsledek: Nejprve se volají konstruk- tory nadřazených tříd, des- truktory pak v opačném sledu

Téma následujícího tutoriálu – C++: Programy pro Windows DĚKUJI ZA POZORNOST