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
Úvod do Úvod do OOPOOP (2/4) (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 Úvod do OOPOOP (3/4) (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 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í)
Úvod do Úvod do OOPOOP (4/4) (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)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)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)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ří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
Třídy bez metod (4/5)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)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 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;}
Příklad: KPC2E_Ex97.cpp
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;}
Příklad: KPC2E_Ex98.cpp
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
Konstruktory a destruktory (2/4)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)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)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)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: KPC2E_Ex100.cpp
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 …
Knihovní třídy (2/3)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)Knihovní třídy (3/3)
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
Třídy ve třídě (2/6)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)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)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)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)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 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řetížení členských funkcí (2/8)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)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)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)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 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
Přetížení členských funkcí (6/8)Přetížení členských funkcí (6/8)
#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ů
Přetížení členských funkcí (7/8)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)Přetížení členských funkcí (8/8)
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
Příklad: KPC2E_Ex104.cpp
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 { }
Dědičnost tříd (2/10)Dědičnost tříd (2/10)
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);
…
Dědičnost tříd (3/10)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)Dědičnost tříd (4/10)
// 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
};
Dědičnost tříd (5/10)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 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;};
Dědičnost tříd (8/10)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)Dědičnost tříd (9/10)
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;}
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