Počítače a programování 2

OSNOVA:a) Úvod do OOP b) Třídy bez metodc) Třídy s metodami d) Konstruktory a destruktorye) Metody const f) Knihovní třídyg) Třídy ve třídě h) Přetížení členských funkcíi) Dědičnost tříd

Jiří ŠebestaJiří ŠebestaÚstav radioelektroniky, FEKT VUT v BrněÚstav radioelektroniky, FEKT VUT v Brně

Počítače a programování 2 pro obor ESTKPC2E

TUTORIÁL 2

Úvod do Úvod do OOPOOP (1/4) (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


- 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)


- 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 OOPZÁ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í)


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)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).


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().


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řídacout je standarní výstupcin 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


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;}



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 classprivate: // 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;}


Třídy s metodami Třídy s metodami (1/4)(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 Třídy s metodami (2/4)(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 Třídy s metodami (3/4)(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 Třídy s metodami (4/4)(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;}


Konstruktory a destruktory (1/4)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í objektuDESTRUKTOR – 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


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.


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}


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

Metody const (1/1)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}


Knihovní třídy (1/3)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 …


… //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)


Instance třídy (vytvoření objektu) z knihovní deklarace třídy

#include "person.hpp" //header file includePerson::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)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 <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;

};

Deklarace třídy pro bod - dvě souřadnice + přístupové metody


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


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


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


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);

}


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 objectint 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)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ří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 () {}…


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);

}


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


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 parametersRect 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


#include <iostream>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 parametersprivate: 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ů


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ů █


int main(){

Rect A(25,5); //new rectangle with initializationstd::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


Dědičnost tříd (1/10)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řídasyntaxe: class derived_class:acces_type basic_class

{declaration}Např. class dog:public mammal { }


Příklad: Ukázka odvození třídy Pes od třídy Savec #include <iostream>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);

…


…void Promluvit() const; //výkonné metody

void Spat() const;protected: int Vek; //privátní proměnné int Vaha;};


// deklarace třídy Pesclass 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

};


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 Dědičnost tříd (6/10)(6/10)Příklad: Třída Dog odvozená ze třídy Mammal a použití

#include <iostream>

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 Dědičnost tříd (7/10)(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;};


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


Mammal::Mammal(): //constructor with inicializationAge(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 Dědičnost tříd (10/10)(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;}


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

Počítače a programování 2

Documents