Objektově orientované programování. RNDr. Jan Lánský, Ph.D. Katedra softwarového inženýrství MFF UK Katedra informatiky VŠFS
|
|
- Emilie Jandová
- před 8 lety
- Počet zobrazení:
Transkript
1 Objektově orientované programování RNDr. Jan Lánský, Ph.D. Katedra softwarového inženýrství MFF UK Katedra informatiky VŠFS (Autor původní verze slajdů: Mgr. Zbyněk Winkler) (Autor prapůvodní verze slajdů: RNDr. Filip Zavoral, Ph.D.) (Část slajdů převzata od: RNDr. David Bednárek)
2 Studijní povinnosti Zápočet Aktivní účast na cvičeních (80 %) Chybějící účast lze nahradit: Vypracováním a předvedením příkladů probraných na cvičení [v semestru] Zápočtový test (praktický příklad, odladěný, 3 hodiny) [kdykoliv] Zápočtový program Téma (do 2. přednášky) Specifikace (do 3. přednášky) Betaverze (do konce semestru) Finální verze (do 30.6.) Zkouška Ústní, s přípravou na PC (2 hodiny) Na zkoušku lze jít i bez zápočtu
3 Literatura Miroslav Virius: Programování v C++ Miroslav Virius: Pasti a propasti jazyka C++ Miroslav Virius: Od C k C++ Scott Meyers: Effective C++, More Effective C++, Effective STL Herb Sutter: Exceptional C++, More Exceptional C++ Que: ANSI/ISO C++ Professional Programmer's Handbook Bruce Eckel: Myslíme v jazyce C++ James O. Coplien: Advanced C++ Programming Styles and Idioms Bjarne Stroustrup: The C++ Programming Language ISO/IEC 14882, ANSI: Programming languages - C++ (1998, 2003)
4 Obsah předmětu ZS (PJC) LS (OOP) C++ C C++ C Paradigmata programování, OOP Objekty, zapouzdření, dědičnost, konstruktory a destruktory Přetěžování funkcí, předefinování operátorů Pozdní vazba, virtuální funkce Abstraktní datové typy Šablony, výjimky, prostory jmen. Objektové knihovny: streams, STL RTTI, OO styly a idiomy...
5 Paradigmata programování Procedurální programování jakou akci mám provést vstup výpočet (algoritmus) výstup black box: procedura / funkce Modulární programování rozdělení problému na komponenty procedury pracují nad daty - rozhraní black box: modul Datová abstrakce vytvoření vlastního datového typu (abstract/user defined datové typy) kompletní množina operací nad tímto typem black box: datový typ Objektové programování dědičnost obecné / konkrétní vlastnosti Polymorfismus odlišné chování potomků možnost pozdějších rozšíření zapouzdření side effects, údržba nelze rozumně rozšiřovat dále generické programování šablony, STL
6 Třídy a objekty Koncepční pohled objekt: entita reagující na vnější podněty třída: množina stejně reagujících entit Technický pohled objekt: struktura obsahující data a funkce, instance třídy (proměnná) třída: typ objektu jednotná struktura dat, stejné operace nad daty Zobecnění pojmu struktura (struct) Rozdíl mezi class a struct v C++ je nepatrný, užívání class je pouze konvence deklarace třídy obsahuje Deklarace datových položek (stejně jako v C) Funkce (metody), virtuální funkce a statické funkce Definice výčtových konstant a typů (včetně vnořených tříd) Rozhraní veřejné informace a služby pro uživatele Implementace (neveřejná) interní data a metody (funkce)
7 Třída zvíře v C++ - rozhraní zvire.h definice třídy rozhraní (veřejné) konstruktor (inicializace) metody class Zvire private: int zaludek; public: Zvire() zaludek = 1; vnitřní stav (privátní) Datová položka int zije() return zaludek>0; int jez( int jidlo); int vymesuj( int objem); inline tělo funkce Deklarace metody
8 Třída zvíře - implementace class Zvire private: int zaludek; public: Zvire()... int zije()... int jez( int jidlo); int vymesuj( int objem); Středník!!! zvire.h Třída metody Přístup k datům metody zvire.cpp #include zvire.h int Zvire::jez( int jidlo) if(! zije()) return 0; return zaludek += jidlo; } int Zvire::vymesuj( int objem) if( (zaludek -= objem) <= 0) zaludek = 0; return zaludek; } :: operátor kvalifikace Implementace (tělo) metody
9 zvire.h class Zvire private: int zaludek; public: Zvire()... Třída zvíře - použití int zije()... int jez( int jidlo); int vymesuj( int objem); Import rozhraní zaludek = 1 zaludek = 6 zaludek = #include zvire.h... }... Zvire pytlik; pytlik.jez(5); pytlik.vymesuj(3); if(! pytlik.zije()) return -1; pytlik.vymesuj(4); if(! pytlik.jez(1))... mujprogram.cpp return -2; Automatický konstruktor Instance třídy = objekt
10 Objekt - instance třídy int Zvire::jez( int jidlo) if(! zije()) return 0; return zaludek += jidlo; } dvě instance třídy... Zvire pytlik, beruska; pytlik.jez( 5); beruska.jez( 1);...? Metoda třídy - ke kterému objektu má přistupovat? pytlik: beruska: zaludek zaludek 6 2
11 this Každá metoda dostane 'tajný' parametr this ukazatel na objekt zvire:: znamena zvire * this C int jez( Zvire* this, int jidlo) if(! zije( this)) return 0; return this->zaludek += jidlo; }... Zvire pytlik, beruska; jez( &pytlik, 5); jez( &beruska, 1);... C++ int Zvire::jez( int jidlo) if(! zije()) return 0; return zaludek += jidlo; }... Zvire pytlik, beruska; pytlik.jez( 5); beruska.jez( 1);... this->zije() this->zaludek this pytlik: zaludek 6 beruska: zaludek 2
12 Reference int x = 1, y = 2; int *px; px = &x; *px = 3; int &ry = y; ry = 4; return *px + ry; reference pouze inicializace nelze měnit 3 x: :px 4 y: :ry reference i ukazatele jsou reprezentovány adresou x: 1 :a y: 2 :b swap( int& a, int& b) int c = a; a = b; b = c; } int x = 1, y = 2; swap( x, y); skutečné parametry odkazy na proměnné zpřehlednění kódu přetěžování funkcí
13 Přetěžování funkcí Funkce je definována svým identifikátorem a počtem a typem parametrů int pocitej( int x) return x+1; } int pocitej( int a, int b) return 2*a + b; } int pocitej( int a, const char* s) return a + strlen( s); } Funkce se stejným identifikátorem ale různým počtem parametrů Funkce se stejným počtem ale různým typem parametrů Správná funkce podle počtu a typů skutečných parametrů pocitej( 1); pocitej( 1, 2); pocitej( 1, "ahoj"); // int pocitej( int) // int pocitej( int, int) // int pocitej( int, char*)
14 Implicitní parametry Některé parametry funkce mohou mít implicitní hodnoty pokud nejsou všechny parametry implicitní implicitní parametry odzadu Při volání funkce lze implicitní parametry vynechat použije se implicitní hodnota int fce( int a, int b = 2, int c = 4) return 2*a + b - c; } fce( 1); // int fce( 1, 2, 4) fce( 1, 5); // int fce( 1, 5, 4) fce( 1, 5, 6); // int fce( 1, 5, 6) Volá se stále stejná funkce int fce( int, int, int) Kdy použít přetěžování a kdy implicitní parametry? Stejný kód pro různý počet parametrů implicitní parametry Pro různé počty nebo typy parametrů různý kód přetěžování
15 Konstruktory class Zvire private: int zaludek; public: Zvire() zaludek = 1; Zvire( int zal) zaludek = zal; Zvire( const Zvire& vzor) zaludek = vzor.zaludek; Zvire beruska; Zvire pytlik( 20); Zvire beberuska( beruska); Zvire tlustoch = pytlik; Implicitní konstruktor bez parametrů Konstruktor s parametry Copy konstruktor X (const X&) vytvoří objekt jako kopii jiného různé zápisy copy konstruktoru Pro U T nejsou zcela ekvivalentní: U u; T t(u); // T::T( U&) T t = u; // T::T( T(u)) nebo // T::T( u.operator T()) zatím lze ignorovat
16 Konstruktor s parametry class Clovek private: char jmeno[50]; Clovek(); public: //Clovek() jmeno[0] = 0; Clovek( char * jmeno) strcpy(this->jmeno, jmeno); Clovek honza("honza"); //Clovek petr; Nejde, zakázali jsme Tímto zakážeme deklarovat objekt bez použití NEimplicitního konstruktoru Využití Předání nastavení objektu Šetří řádky kódu Zakázat implicitiní konstruktor Dobře rozvážit zda zakázat Bezpečnost proti nezadání klíčové hodnoty identifikátor
17 Přetěžování operátorů - deklarace class Bod private: int x, y; public: Bod( int xx=0, int yy=0) x=xx; y=yy; Bod operator+( const Bod&); Bod operator=( const Bod&); Bod a(1,2), b, c; c = a + b; implicitní parametry implicitní konstruktor přetížení operátoru + a + b a = b Bod::Bod(0,0); a.operator+(b) a.operator=(b) c.operator=(a.operator+(b)); c.assign( a.add( b));
18 Přetěžování operátorů těla metod x this->x Bod Bod::operator=( const Bod& b) x = b.x; y = b.y; return *this; } Bod Bod::operator+( const Bod& b) return Bod( x+b.x, y+b.y); } reference aktualizace stavu kopie objektu (hodnotou přiřazení je přiřazovaná hodnota) co to je??? vytvoření dočasného objektu konstruktor Bod::Bod(int, int)
19 Přetěžování operátorů - pravidla Většinu operátorů jazyka C++ lze definovat pro uživatelské datové typy Nelze předefinovat tyto operátory:..* ::? : sizeof Alespoň jeden z operandů musí být třída nebo výčtový typ nebo reference na ně Nelze předefinovat operace na číselných typech a ukazatelích Předefinováním nelze měnit prioritu a asociativitu operátorů Pro předefinované operátory nemusí platit identity definované pro základní typy ++a nemusí být ekvivalentní a=a+1 a[b] nemusí být ekvivalentní *(a+b) ani b[a] je však velmi doporučeno dodržovat běžnou sémantiku Pro předefinované operátory && a neplatí pravidla o zkráceném vyhodnocování Typy skutečných operandů nemusejí přesně odpovídat typům formálních parametrů stejná pravidla jako pro přetížené funkce
20 Přetěžování operátorů ekvivalence Pozor! Pro předefinované operátory nemusí platit identity definované pro základní typy: a=a+b a+=b a[b] *(a+b) Bod Bod::operator+=( const Bod& b) x += b.x; y += b.y; return *this; } Bod Bod::operator+=( const Bod& b) return *this = *this + b; } this->operator=( this->operator+( b))
21 copy konstruktor a operator= class Bod private: int x, y; public: Bod( const Bod& b) x=b.x; y=b.y; Bod operator=( const Bod& b) x=b.x; y=b.y; return *this; Bod a(1,2); Bod k, m(a), n = a; k = m; není-li copy konstruktor nebo operator= definován, automaticky se vygeneruje copy konstruktor resp. operator= všech složek copy konstruktor definice nového objektu operator= přiřazení do existujícího objektu Rozdíl mezi copy konstruktorem a přiřazením: copy konstruktor se nemusí starat o předchozí stav objektu, přiřazení ano přiřazení vrací (přiřazovanou) hodnotu, copy konstruktor nevrací nic
22 Udržovatelnost kódu class Bod public: Bod( const Bod & b) dosad(b); Bod operator=( const Bod & b) dosad(b); return *this; int GetX() return x; int GetY() return y; void SetX(int x) this->x = x; } void SetY(int y) this->y = y; } private: int x, y; void dosad( const Bod & b) x=b.x; y=b.y; Těla operátorů a konstruktorů volání jiné funkce Public část před private Private položky nejsou zajímavé Datové položky vždy private Funkce Get a Set Těla metod vždy v *.cpp souboru Pro pozdější rozšíření Lépe se hledá kde je implementované Jména tříd ToJeMojeTrida Jména funkcí proměnných mojeprvnifunkce
23 Objekt a ukazatel na objekt C++ odlišuje objekt a ukazatel na něj Rozdíl oproti jiným jazykům Java, JavaScript, PHP, VisualBasic,... Analogie s chováním stuct v C Ukazatel nelze použít dokud není splněna jedna z možností: Přiřazen existující objekt Reference Dynamicky vytvořen nový objekt Operátor new class Zvire... Zvire * pytlik; Zvire beruska; pytlik = &beruska; pytlik = new Zvire; Nevzniká tu žádný objekt vzniká nový objekt
24 Operátory new a delete new: alokace paměti, zavolání konstruktoru není nutno testovat úspěšnost mechanismus výjimek delete: zavolání destruktoru, dealokace paměti jako parametr lze i 0 Bod a(1,2); Bod *pb = new Bod; *pb = a + a; a = *pb; delete pb; pb = new Bod( a); Bod *pc = new Bod( 3, 5); a = *pb + *pc; delete pc; delete pb; char* buf = new char[10]; strcpy( buf, ahoj );... delete[] buf; dynamická alokace, implicitní konstruktor náhrada za malloc() uvolnění paměti další alokace, explicitní konstruktory alokace pole objektů uvolnění paměti - u alokovaných polí nutno []
25 Chytré řetězce nápad Práce s řetězci v C + efektivní nepohodlá a těžkopádná časté chyby Chtěl bych: přiřazování, zřetězení, automatická alokace místa Str s1 = ahoj ; Str s2 = babi ; Str s3; s3 = s1 + + s2; s3 +=. ; s3 = (char*) malloc( strlen(s1) + strlen(s2) + 2); strcpy( s3, s1); s3[ strlen(s1)] = ; strcpy( s3 + strlen(s1) + 1, s2); obyčejné zřetězení nechci se starat o to, kde sebrat místo
26 Chytré řetězce - třída class Str private: char* buf; public: Str() buf = 0; Str( const Str& s); Str( const char* s); ~Str() delete[] buf; ukazatel na alokovaná data Str& operator=( const Str& s); Str operator+( const Str& s); implicitní konstruktor prázdný řetězec int len() const return buf? strlen(buf) : 0; destruktor objekt si musí po sobě uklidit delete přežije i 0, nemusím testovat operace s řetězci další metody (délka řetězce) Konstantní funkce, nemodifikuje objekt
27 Destruktory class Str private: char* buf; ukazatel na alokovaná data public: Str() buf = 0; Str( const char* s) buf = new char[ strlen( s) + 1]; strcpy( buf, s); ~Str() delete[] buf; nemá argumenty nic nevrací alokace paměti pro řetězec destruktor - automaticky se volá při zrušení objektu
28 Vyvolání destruktoru v kostruktoru s1 se alokuje paměť pro řetězec fce() Str s1 = ahoj ; Str* s2 = new Str( babi );... delete s2;... } zde končí život s1 automaticky se vyvolá destruktor dynamická alokace sp2 delete zavolá destruktor (a potom uvolní paměť)
29 Řetězce implementace Str& Str::operator=( const Str& s) delete[] buf; if(! s.len()) buf = 0; } else buf = new char[ s.len()+1]; strcpy( buf, s.buf); } return *this; } Str::Str( const Str& s)... } uklidit po předchozím řetězci prázdný řetězec alokace paměti okopírování znaků přiřazená hodnota objekt sám reference kvůli efektivitě copy konstruktor totéž bez delete a return
30 O něco lepší implementace class Str private: char* buf; void copy( const char* s); privátní metoda alokace a kopírování později si ukážeme ještě lepší counted pointers public: Str() buf = 0; Str( const Str& s) copy( s.buf); Str( const char* s) copy( s); ~Str() clear(); konstruktory: jen alokace a kopírování Str& operator=( const Str& s) clear(); copy( s.buf); return *this; Str& operator=( const char* s) clear(); copy( s); return *this; přiřazení: i uklizení a návratová hodnota void clear() delete[] buf; často potřebujeme uklízet!!! buf = 0; nebo private!!!
31 Implementace kopírování class Str private: char* buf; void copy( const char* s); předpokládáme prázdný buf zařídí volající metoda - copy je private public: Str() buf = 0; Str( const Str& s) copy( s.buf); Str( const char* s) copy( s); ~Str() clear(); Str& operator=( const Str& s) clear(); copy( s.buf); return *this; Str& operator=( const char* s) clear(); copy( s); return *this; void clear() delete[] buf; Jde clear() přidat do copy()??? void Str::copy( const char* s) if(!s!*s) buf = 0; } else buf = new char[ strlen( s)+1]; if( buf) strcpy( buf, s); } } alokace a kopírování zkontrolovat prázdný řetězec
32 Zřetězení Str Str::operator+( const Str& s) Str newstr; newstr.buf = new char[ len() + s.len() + 1]; strcpy( newstr.buf, buf); strcat( newstr.buf, s.buf); return newstr; } Str Str::operator+( const char* s) Str newstr; newstr.buf = new char[ len() + strlen(s) + 1]; strcpy( newstr.buf, buf); } strcat( newstr.buf, s); return newstr; nelze návrat reference (lokální dočasný objekt) nové hodnoty VŽDY vracet hodnotou nový prázdný řetězec místo na znaky první operand druhý operand návratová hodnota
33 Připojení řetězce když už umíme + a = proč si neudělat += class Str... public:... Str& operator=( const Str& s); Str& operator=( const char* s); Str operator+( const Str& s); Str operator+( const char* s); Str& operator+=( const Str& s) *this = *this + s; return *this; Str& operator+=( const char* s) *this = *this + s; return *this; operator+( Str&) lze vracet referencí existující hodnota operator+( char*)
34 Str a jednotlivé znaky class Str... public: Str(); Str( const Str&); Str( const char*); Str( char c) buf = new char[ 2]; buf[0] = c; buf[1] = '\0'; dodefinovat konstruktor, přiřazení a operace pro další typ Str& operator=( const Str&); Str& operator=( const char*); Str& operator=( char); Str operator+( int); Str operator+=( int);
35 Výstup později si ukážeme elegantnější řešení - streams neprázdný obsah na stdout normálně spojím řetězce s mezerou... a vytisknu dočasný objekt reference na s3 class Str... public: int print() const return buf? printf( "%s", buf) : 0; Str s1 = "ahoj", s2("babi"), s3; s3 = s1 + ' ' + s2; s3.print(); Str("\n").print(); (s3 += ".\n").print();
36 ... and together class Str private: char* buf; void copy( const char* s); void clear(); public: Str() buf = 0; Str( const Str& s); Str( const char* s); Str( char c); ~Str(); Str& operator=( const Str& s); Str& operator=( const char* s); Str& operator=( char c); Str operator+( const Str& s); Str operator+( const char* s); Str operator+( char c); Str& operator+=( const Str& s); Str& operator+=( const char* s); Str& operator+=( char c); int len() const; int print() const;
37 Dědičnost vztah tříd předek-potomek hierarchie přesnější názvosloví: základní (base) / odvozená třída (derived class) vícenásobná dědičnost dvakrát měř, jednou řež, protokoly specializace potomek má/umí něco navíc reusabilita jiné chování bez změny původní třídy Zvíře Pes Pitbul jez, vyměšuj sedni, lehni trhej Člověk uč_se
38 class Zvire protected: int zaludek; public: Zvire(); Zvire( int jidlo); int zije(); int jez( int jidlo); int vymesuj( int objem); pes jako potomek zvířete - definice Přístup pro třídu a potomky class Pes : public Zvire private: enum t_stav Stoji, Sedi, Lezi t_stav stav; public: Pes() stav = Stoji; přidaná položka void sedni() stav = Sedi; t_stav codela() return stav; } potomek (odvozená třída od) Zvířete položky předka položky potomka žaludek stav jez, vyměšuj sedni potomek obsahuje všechny položky a metody předka metody předka metody potomka Zvire pytlik; Pes azor; pytlik.jez(); azor.jez(); azor.sedni();
39 Konstruktor a destruktor předka class Zvire... ~Zvire() printf( "zabijim zvire "); class Pes : public Zvire... public: Pes() stav = Stoji; Pes( int jidlo) : Zvire( jidlo) stav = Stoji; ~Pes() printf( "zabijim psa "); Pes azor;... } implicitní konstruktor předka (automaticky) explicitní konstruktor předka konstruktory předků a vložených tříd se volají před konstruktorem potomka destruktor předka se vyvolá automaticky po ukončení destruktoru potomka zabijim psa zabijim zvire
40 Kompatibilita předka a potomka Potomka lze přiřadit do předka (platí i pro ukazatele) Předka NELZE přiřadit do potomka (platí i pro ukazatele) pes umí jíst, brouk neumí štěkat Zvire pytlik, *pz; Pes azor, *pp; pytlik = azor; pz = &azor; azor = pytlik; pp = &pytlik; nelze pytlik žaludek azor žaludek stav azor žaludek stav pytlik žaludek???
41 Polymorfismus odlišné chování potomků pozdní vazba (late binding) Zvíře Pes Pitbul jez jez jez najde něco v přírodě Člověk sní maso sní hodně masa jez jde do restaurace
42 Polymorfismus - motivace class Zvire jez() priroda(); class Pes : public Zvire jez() maso(1); class Pitbul : public Pes jez() maso(10); class Clovek : public Zvire jez() hospoda(); Každá třída má vlastní implementaci (tělo) metody jez Zvire pytlik; Pes punta; Pitbul zorro; Clovek pepa; Tohle není polymorfismus! pytlik.jez(); // priroda(); punta.jez(); // maso(1); zorro.jez(); // maso(10); pepa.jez(); // hospoda(); 'normální' vlastnost tříd zakrývání metod Při překladu je známo ze které třídy se volá metoda
43 Polymorfismus takto nelze do ukazatele na základní třídu (předka) dám ukazatel na nově vytvořený objekt odvozené třídy (potomka) Zvire* z; z je ukazatel na zvíře volá se Zvire::jez() z = new Pes; z->jez(); // priroda(); z = new Clovek; z->jez(); // priroda(); pokus 'na tvrdo' chci metodu potomka Zvire* z; z = new Pes; z->pes::jez(); nelze - syntaktická chyba pes není předkem zvířete // priroda(); z = new Clovek; z->clovek::jez(); // priroda();
44 Polymorfismus takto bych to chtěl chtěl bych, aby se volaly 'správné' metody Zvire* z; z = new Pes; z->jez(); // maso(1); z = new Clovek; z->jez(); // hospoda(); Zvire* naserodina[3]; naserodina[0] = new Clovek; naserodina[1] = new Pes; naserodina[2] = new Pitbul; for( int i = 0; i < 3; i++) naserodina[i]->jez(); Chci pokaždé se zavolat jinou metodu Rozlišení metody se musí dít za běhu
45 Virtuální funkce - deklarace class Zvire virtual jez() priroda(); class Pes : public Zvire virtual jez() maso(1); class Pitbul : public Pes virtual jez() maso(10); magické klíčové slovo virtual každý objekt si s sebou nese informaci kterou virtuální funkci používá class Clovek : public Zvire virtual jez() hospoda();
46 Virtuální funkce - implementace Zvire * z; z = new Zvire; Zvire žaludek jez z = new Pes; tabulka virtuálních funkcí Pes žaludek jez stav Zvire::jez() priroda(); Pes::jez() maso(1); z->jez(); zavolá se správná metoda podle tabulky virtuálních funkcí
47 Virtuální funkce a konstruktory a destruktory v konstruktoru a destruktoru se vždy volá metoda vytvářeného/rušeného objektu class A public: virtual f(); A() f(); // A::f ~A() f(); // A::f g() f(); // A/B::f class B : public A public: virtual f(); B() f(); // A::A B::f ~B() f(); // B::f A::~A g() f(); // B::f nejdřív se zavolá konstruktor předka určí se za běhu podle skutečného typu objektu nejdřív se provede kód destruktoru, pak se zavolá destruktor předka
48 Volání virtuálních funkcí class A public: virtual f(); class B : public A public: virtual f(); A a; // A::A B b; // B::B A * paa = &a; A * pab = &b; B * pbb = &b; // B * pba = &a; nelze!! (předka do potomka) a b A::f B::f paa pab pbb a.f(); b.f(); paa->f(); pab->f(); pbb->f(); // A::f // B::f // A::f // B::f // B::f b.a::f(); // A::f b.b::f(); // B::f a.b::f(); // NE! paa->a::f(); // A::f pab->a::f(); // A::f pab->b::f(); // NE! pbb->a::f(); // A::f pbb->b::f(); // B::f pozdní vazba kvalifikované volání
49 Abstraktní třída, čistě virtuální funkce int armada; class Vojak public: enum THod vojin, desatnik, porucik, general Vojak( THod hod = vojin) hodnost=hod; armada++; virtual void pal() = 0; virtual ~Vojak() armada--; private: THod hodnost; POZOR!!! Nutný virtuální destruktor pure virtual function abstraktní třída společné rozhraní abstraktní třída nelze vytvořit objekt společný předek class Samopal class Kalasnikov : public Samopal class Pesak : public Vojak private: Samopal* sam; public: Pesak( THod hod=vojin) : Vojak( hod) sam = new Kalasnikov; virtual void pal() sam->pal(); virtual ~Pesak() delete sam;
50 Abstraktní třídy, virtuální destruktory pokud by ~Vojak nebyl virtuální // Vojak v; // NELZE abstraktní třída Pesak p; // OK Pesak Vojin Pesak* pp = new Pesak; // OK pp->pal(); // Pesak::pal Vojak* pv = new Pesak; // OK pv->pal(); // Pesak::pal delete pp; // OK, Pesak::~Pesak delete pv; //!!! Vojak::~Vojak POZOR!!! nejsou-li destruktory virtuální, nezruší se samopal Řešení: virtuální destruktor class Vojak virtual ~Vojak() armada--; class Pesak : public Vojak virtual ~Pesak() delete sam;
51 Nesprávné užití dědičnosti Letadlo není potomkem svého motoru Důkaz: Co když má dva motory... Násobná dědičnost? Ne: Je třeba je odlišit Kompozice Skládání velkých objektů z malých C++: Třída s datovými položkami Jezevčík umí vyhnat lišku z nory... Myslivec s jezevčíkem tedy také... Myslivec není potomkem svého jezevčíka Důkaz: Nežere granule... Kompozice? Ne: Nerodí se zároveň Delegace Převedení funkčnosti na jiný objekt C++: Ukazatel Mlok není potomkem ryby a savce Důkaz: Nemá dvě hlavy... Virtuální dědičnost? Ne: Nekojí Tlačítko není potomkem obdélníku a textu Společný abstraktní předek Obratlovec Vizuální objekt
52 Prostory jmen (namespaces) zapouzdření identifikátorů prevence kolizí (velké projekty, knihovny) stejné identifikátory v různých prostorech jmen namespace aa int p; int f1( int x) return x + p; } int f2( int x, int y); } int aa::f2( int x, int y) return p * (x + y); } aa::f1( aa::f2( 5, 6)); definice prostoru jmen přístup k identifikátoru ze stejného prostoru definice funkce mimo prostor jmen přístup k identifikátorům přes ::
53 Prostory jmen prostor jmen se může opakovaně otevírat a zavírat explicitní přístup ke globálnímu identifikátoru ::id standardní knihovny namespace std using namespace std; namespace aa int p; int q; } int g( int n) cout << (n + aa::p); } namespace aa int f3( int x) return 1 + ::g( x); } rozbalení std přístup do aa přístup k identifikátorům std znovuotevření prostoru aa přístup ke globálnímu identifikátoru
54 Prostory jmen a standardní knihovny stará konvence: stdio.h, ctype.h, iostream.h identifikátory v globálním prostoru jmen strlen, FILE nová konvence: cstdio, cctype, iostream identifikátory uzavřené do namespace std std::strlen, std::file standardní knihovny C++ Základní knihovny z C přejmenované podle nové konvence Rozšířené C++ knihovny iostream: znakový formátovaný vstup a výstup STL: Standard Template Library použití šablon kontejnery, iterátory, algoritmy
55 Vstup a výstup - proudy (streams) hierarchie tříd pro (formátovaný znakový) vstup a výstup jednotné rozhraní pro v/v do souborů a paměti,... operátory << a >>, manipulátory motivace: rozšiřitelnost bezpečnost datum d( 12, 3, 2004); printf( "dnes je %?", d); int i; printf( "Jmenuji se %s", i); #include <iostream> using namespace std; int main() int n; cout << "Rekni cislo: "; cin >> n; cout << "Mam vic: " << (n+1) << ", hec!" << endl; } definice základních tříd a manipulátorů ostream cout istream cin FILE* stdout FILE* stdin ostream& ostream::operator<< () istream& istream::operator>> ()
56 Streams hierarchie tříd
57 Hlavičkové soubory <iostream> základní operace, standardní v/v, manipulátory bez parametrů cin, cout, <<, >>, endl, ws,... <iomanip> manipulátory s parametry setw, setfill,... <fstream> vstup a výstup do souborů fstream, ifstream, ofstream,... <strstream> - vstup a výstup do paměti (chytré řetězce) strstream, istrstream, ostrstream,...
58 Manipulátory do proudu lze vkládat manipulátory změní stav proudu endl left, right dec, hex ws setw(int) setfill(int) pošle buffer na výstup a odřádkuje zarovnávej doleva / doprava v desítkové / šestnáctkové soustavě přeskoč bílé znaky (na vstupu) šířka výstupního pole (jen pro následující číselnou položku) výplňkový znak... a spousty dalších cout << "[" << setfill('.') << setw(5) << 17 << "]" << endl; [...17] nastaví výplňový znak nastaví šíři výstupu vytiskne podle aktuálního nastavení výstup
59 Výstup do souboru třída pro souborový proud spojení proudu se souborem v konstruktoru #include <fstream> using namespace std; int main() fstream f( "C:\\src\\pokus.txt", ios::out); if(! f) error(); f << "bubu" << endl; } způsob otevření ios::in, out, app, trunc, binary,... Př: ios::in ios::binary soubory není třeba zavírat, zavře je automaticky destruktor operator! (ostream&) vrátí true když se operace nepodařila
60 Další metody vstupních proudů pro binární vstup a výstup nelze použít operátory << a >> Vstup get( kam, délka, koncový_znak) getline( kam, délka, koncový_znak) ignore( délka, koncový_znak) read( pole_znaků, délka) tellg() seekg( posun, odkud) unget() Výstup put( znak) write( pole_znaků, délka) tellp() seekp(posun, odkud) flush()... a další int i = 17; ofstream f( "pokus.txt", ios::binary); if(! f) error(); f.write( (char*)&i, sizeof( i)); pole bajtů a jejich počet
61 Spřátelené funkce vlastní výstup class Complx private: int re, im; public: Complx( int _re = 0, int _im = 0) re = _re; im = _im; friend ostream& operator<<( ostream& s, Complx& c) return s << c.re << "+" << c.im << "i"; POZOR! Toto není metoda třídy! Complx x(1,2); cout << x << endl; spřátelená (friend) funkce může přistupovat k privátním položkám
62 Šablony množina funkcí/tříd lišících se pouze typem parametrů/položek vzor, podle kterého překladač vytvoří funkci nebo třídu (instanci) pro konkrétní typ Definice šablony funkce Typový parametr T nahrazuje skutečný typ místo typename lze class template <typename T> T max( T a, T b) return a > b? a : b; int x = 10, y = 20; double m = 1.1, n = 2.2; cout << max(x,y) << max(m,n) << endl; int max( int a, int b) double max( double a, double b)
63 Šablony tříd - definice template<typename T> class Guma private: int size; T* array; public: const int default_size = 10; Guma( int _size = default_size) size = _size; array = new T[size]; ~Guma() delete array; } T& operator[] (int n); size: 5 array: 0? 1? 2? pole neznámého typu 3? 4? int main() Guma<int> ip(5); ip[3] = 999; instance šablony třídy definice proměnné přetížený operator[]
64 Šablony metod, instance šablon template<typename T> class Guma private: int size; T* array; public: T& operator[] (int n); template<typename T> T& Guma<T>::operator[] (int n) if( n >= size) T* na = new T[ n + 1]; for( int i = 0; i < size; i++) na[i] = array[i]; delete array; array = na; size = n + 1; } return array[n]; } definice šablony metody struct Krabice int a, b; char jm[10]; typedef Guma<Krabice> polekrab; int main(int argc, char* argv[]) Guma<int> ip(5); polekrab pk; ip[3] = 999; pk[12].a = ip[3]; pk[i] je typu Krabice& instance šablony třídy definice typu
65 STL Standard Template Library kontejnery datové struktury pro ukládání dat a manipulaci s nimi iterátory třídy pro přístup k datům kontejnerů algoritmy základní algoritmy nad kontejnery (třídění, procházení, hledání) další pomocné třídy alokátory, komparátory, funktory... list<int> sez; sez.push_front( 1); sez.push_back( 2); sez.push_front( 3); list<int>::iterator i; for( i = sez.begin(); i!= sez.end(); i++) cout << "[" << *i << "]"; obousměrný seznam přidání prvku zepředu... zezadu... zepředu iterátor seznamu průchod seznamem přístup k datům přes iterátor operator*
66 STL kontejnery Sekvenční kontejnery uspořádané Asociativní kontejnery setříděné
67 STL kontejnery Sekvenční kontejnery deque dvoustranná fronta [dek] umožňuje v konst. čase přidávat na začátek i konec implementace typicky pomocí polí adaptéry (specializované použití i rozhraní): stack, queue, priority_queue vector pole (gumové) přístup k prvku v konstantním čase jako vector se chová i string a standardní pole (T x[]) string chytré řetězce =, +, += a mnoho dalších operací a metod list dvousměrný seznam implementace: spojový seznam umožňuje v konstantním čase přidávat prvky na libovolné místo Asociativní kontejnery map, multimap zobrazení, asociativní pole, slovník, mapa uspořádaná struktura indexovaná libovolným typem, pair: klíč, hodnota) set, multiset množina, multimnožina každý prvek nejvýše jednou / vícekrát
68 STL iterátory a metody kontejnerů kontejner<t>::iterator T& iterator::operator* iterátor příslušného kontejneru přístup k prvku přes iterátor begin(), end() push_front(), push_back() pop_front(), pop_back() front(), back() operator[], at() insert(iterator,t) size(), empty(), clear() push(), pop(), top() iterátor na začátek / za(!) konec kontejneru přidání prvku na začátek / konec odebrání prvku ze začátku / konce nevrací hodnotu! prvek na začátku / konci přímý přístup k prvku vložení prvku na místo určené iterátorem velikost / neprázdost / smazání kontejneru přidání / odebrání / prvek na vrcholu zásobníku
69 STL použití iterátorů vytvoření celočíselného vectoru pole p je iterátor do vector<int> jestli p už nedosáhl konce pole.end() vrátí iterátor za konec pole pole.begin() vrátí iterátor na začátek pole vector<int> pole; vector<int>::iterator p; for( p = pole.begin(); p!= pole.end(); p++) cout << "[" << *p << "]"; *p (overl.) vrátí hodnotu prvku na nějž ukazuje iterátor p++ (overl.) zařídí, že p bude ukazovat na další prvek
70 STL použití asociativního pole map<string,string> ts; ts["filip"] = " "; ts["petra"] = " "; ts["david"] = " "; ts["kuba"] = " "; cout << "Telefon Petry: " << ts["petra"] << endl; map<string,string>::iterator ti; for( ti = ts.begin(); ti!= ts.end(); ti++) cout << ti->first << ": " << ti->second << endl; operator [] (const string&) vyhledání podle first ts: pair: string first string second pair<string,string> iterator::operator* ti->first (*ti).first
71 Inicializace STL algoritmy fill Fills a sequence with an initial value fill_n Fills n positions with an initial value copy Copies a sequence into another sequence copy_backward Copies a sequence into another sequence generate Initializes a sequence using a generator generate_n Initializes n positions using a generator swap_ranges Swaps values from two parallel sequences Vyhledávání find find_if Finds an element matching the argument Finds an element satisfying a condition adjacent_find Finds consecutive duplicate elements find_first_of Finds one member of a seq. in another seq. find_end search Finds the last occurr. of a sub-seq. in a seq. Matches a sub-sequence within a sequence max_element Finds the maximum value in a sequence min_element Finds the minimum value in a sequence mismatch Mazání remove unique Ostatní for_each Finds first mismatch in parallel sequences Removes elements that match condition Removes all but first of duplicate values Applies a function to each element + mnoho dalších Transformace prvků reverse Reverses the elements in a sequence replace Replaces specific values with new value replace_if Replaces elements matching predicate rotate Rotates elements in a sequence around a point next_permutation Generates permutations in sequence prev_permutation Generates permutations in reverse seq. inplace_merge Merges two adjacent sequences into one random_shuffle Randomly rearranges elements in a seq. Třídění sort Sorts all elements make_heap Converts a range into a heap Skalární výpočty count Counts number of elements matching value count_if Counts elements matching predicate accumulate Reduces sequence to a scalar value equal Checks two sequences for equality lexicographical_compare Compares two sequences Výpočty generující sekvence transform Transforms each element partial_sum Generates sequence of partial sums adjacent_difference Gen. sequence of adjacent differences
72 STL použití algoritmů vlastní funkce pro jeden prvek pro každý prvek se zavolá funkce najde max. prvek vrátí iterátor vyplní se náhodnými čísly setřídí část pole od max. prvku do konce void tiskni( int x) cout << " [" << x << "]"; } vector<int> pole; vector<int>::iterator b, e, p; generate( b = pole.begin(), e = pole.end(), rand); for_each( b, e, tiskni); p = max_element( b, e); sort( p, e); unique( p, e); for_each( b, pole.end(), tiskni);!! pozor může zneplatnit iterátor e odstraní duplicity
73 STL chybová hlášení \SRC\templ\templ.cpp(101) : error C2664: 'class std::_tree<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::pair<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,struct std::map<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >::_Kfn,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >::iterator thiscall std::map<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >::insert(class std::_tree<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::pair<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,struct std::map<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >::_Kfn,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >::iterator,const struct std::pair<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > &)' : cannot convert parameter 1 from 'char [6]' to 'class std::_tree<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::pair<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,struct std::map<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >::_Kfn,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >::iterator'
74 string constructors Create or copy a string size(), length() Return the number of characters destructor =, assign() swap() +=,append(), push_back() insert() erase() clear() resize() Destroys a string Assign a new value Swaps values between two strings Append characters Inserts characters Deletes characters Removes all characters (makes it empty) Changes the number of characters (deletes or appends chars at the end) max_size() empty() capacity() [], at() >>, getline() << copy() c_str() Returns the maximum possible number of characters Returns whether the string is empty Returns the number of characters that can held without be reallocation Access a character Read the value from a stream Writes the value to a stream Copies or writes the contents to a C-string Returns the value as C-string replace() Replaces characters data() Returns the value as character array + Concatenates strings substr() Returns a certain substring ==,!=,<,<=, >,>=, compare() Compare strings find functions begin(), end() rbegin(), rend() Search for a certain substring or character Provide normal iterator support Provide reverse iterator support get_allocator() Returns the allocator
75 Výjimky Motivace: co dělat, když (knihovní) funkce zjistí chybu? nedostatek paměti, nelze otevřít soubor, nulový ukazatel,... Vypsat zprávu na 'obrazovku' a skončit FUJ! Nikdy! Nastavit do globální funkce příznak chyby problém s více vlákny, nutnost neustále testovat Vrátit 'divnou' hodnotu takhle funguje většina knihovních funkcí C nepříliš praktické, testování každé funkce, vnořené testy divná hodnota nemusí existovat Co chceme: oddělit detekci výjimečné situace od jejího zpracování po výskytu 'chyby' (výjimečné situace) automaticky skočit na zpracování kulturně po sobě uklidit (volání destruktorů) Řešení v C++: mechanismus výjimek
76 Výjimky - jednoduchý příklad void mojefce( char* str) if(! str) throw runtime_error( "Nic!"); cout << str; } int main(int argc, char* argv[]) char* p = 0; try mojefce( p); } catch( runtime_error& e) cout << "Chyba: " << e.what() << endl; } return 0; } vyvolání výjimky typ výjimky standardní třída potomek exception pokusný blok try block handler(y) typ výjimky standardní metoda třídy runtime_error řetězec z konstruktoru
77 Výjimky - jednoduchý příklad char* mojefce( long n) char* bigbigbig = new char[n]; cout << "Proslo to" << endl; return bigbigbig; } int main(int argc, char* argv[]) char* p = 0; try mojefce( ); cout << "Vratil jsem se" << endl; } catch( runtime_error& e) cout << "Chyba: " << e.what() << endl; } pokud se nepovede naalokovat, nastane výjimka při výjimce se dále nepokračuje, hledá se nejbližší volný handler nalezený handler return 0; }
78 Výjimky - pravidla k try bloku může být několik handlerů s různými typy try bloky mohou být vnořené výjimka může být vyvolána v libovolně zanořené funkci po vyvolání výjimky se řízení předá handleru s odpovídajícím typem před odchodem ze všech bloků se zavolají destruktory lokálních objektů předávaná hodnota nese informaci o výjimce typické použití: potomek standardní třídy exception i pro výjimky platí, že potomek může nahradit předka konstruktor runtime_error(string&), metoda string what() po ošetření výjimky pokračuje program za handlery try bloku při běhu bez výjimky se handlery ignorují (přeskočí) neošetřená výjimka unhandled exception, konec programu
79 Specifikace výjimek funkcí Problém: jak programátor pozná které výjimky má ošetřovat? Řešení: funkce může specifikovat výjimky, které může vyvolat funkce může vyvolat výjimky těchto typů void mojefce( char* s) throw (runtime_error, mojechyba); int jinafce( void) throw(); char* tretifce( char* s); funkce nevyvolává žádnou výjimku funkce může vyvolat libovolnou výjimku
80 ... co jsme neprobrali spoustu věcí jazyk protected, volatile, static, operátory.* a ->*, ukazatele na funkce a metody,... vícenásobná dědičnost, protokoly RTTI, typeid, type_info static_cast, dynamic_cast, reinterpret_cast, const_cast podrobněji knihovny, zejména streams a STL, efektivní používání knihoven OOP counted pointers, mělké vs. hluboké kopie objektová paradigmata zprávy, obálkové třídy, subtyping, forwarding hlouběji o objektovém návrhu, reusabilitě, efektivitě implementace funktory a jiné specialitky spoustu věcí kdo chcete C++ opravdu profesionálně používat, přečtěte si literaturu (Meyers, Sutter) nebuďte líní zkoušejte i jednoduché věci naprogramovat 'profesionálně'
81 Dodelat na priste Vice slajdu o pretezovani operatoru (i unarni) Vice slajdu o referenci Chytre retezce pocitane odkazy
Objektově orientované programování. RNDr. Jan Lánský, Ph.D. Katedra softwarového inženýrství MFF UK Katedra informatiky VŠFS
Objektově orientované programování RNDr. Jan Lánský, Ph.D. Katedra softwarového inženýrství MFF UK Katedra informatiky VŠFS (Autor původní verze slajdů: Mgr. Zbyněk Winkler) (Autor prapůvodní verze slajdů:
VíceŠablony, kontejnery a iterátory
7. října 2010, Brno Připravil: David Procházka Šablony, kontejnery a iterátory Programovací jazyk C++ Šablony Strana 2 / 21 Šablona funkce/metody Šablona je obecný popis (třídy, funkce) bez toho, že by
VíceŠablony, kontejnery a iterátory
11. března 2015, Brno Připravil: David Procházka Šablony, kontejnery a iterátory Programovací jazyk C++ Šablony Strana 2 / 31 Obsah přednášky 1 Šablony 2 Abstraktní datové struktury 3 Iterátory 4 Array
VícePB161 Programování v jazyku C++
PB161 Programování v jazyku C++ Textové řetězce (2. část) Vstupy a výstupy STL Základ (0. část) Manipulátory Kontejnery Iterátory Algoritmy Řetězce ve stylu C++ Používá se třída string. Řetězec ve stylu
VícePB161 Programování v C++ Proudy pro standardní zařízení Souborové proudy Paměťové proudy Manipulátory
PB161 Programování v C++ Proudy pro standardní zařízení Souborové proudy Paměťové proudy Manipulátory Výhody objektového řešení Nástroje pro IO operace jsou v C++ součástí knihoven Hierarchie objektových
Vícepřetížení operátorů (o)
přetížení operátorů (o) - pro vlastní typy je možné přetížit i operátory (tj. definovat vlastní) - pro definici slouží klíčové slovo operator následované typem/znakem operátoru - deklarace pomocí funkčního
VíceJazyk C++, některá rozšíření oproti C
Karel Müller, Josef Vogel (ČVUT FIT) Jazyk C++, některá rozšíření oproti C BI-PA2, 2011, Přednáška 1 1/22 Jazyk C++, některá rozšíření oproti C Ing. Josef Vogel, CSc Katedra softwarového inženýrství Katedra
VíceProgramování v C++ 2, 4. cvičení
Programování v C++ 2, 4. cvičení statické atributy a metody, konstruktory 1 1 Fakulta jaderná a fyzikálně inženýrská České vysoké učení technické v Praze Zimní semestr 2018/2019 Přehled Přístupová práva
VíceProgramování v C++ 1, 5. cvičení
Programování v C++ 1, 5. cvičení konstruktory, nevirtuální dědění 1 1 Fakulta jaderná a fyzikálně inženýrská České vysoké učení technické v Praze Zimní semestr 2018/2019 Přehled 1 2 3 Shrnutí minule procvičené
Více2) Napište algoritmus pro vložení položky na konec dvousměrného seznamu. 3) Napište algoritmus pro vyhledání položky v binárním stromu.
Informatika 10. 9. 2013 Jméno a příjmení Rodné číslo 1) Napište algoritmus pro rychlé třídění (quicksort). 2) Napište algoritmus pro vložení položky na konec dvousměrného seznamu. 3) Napište algoritmus
VíceProgramování v C++ 1, 6. cvičení
Programování v C++ 1, 6. cvičení dědičnost, polymorfismus 1 1 Fakulta jaderná a fyzikálně inženýrská České vysoké učení technické v Praze Zimní semestr 2018/2019 Přehled 1 2 3 Shrnutí minule procvičené
VícePokročilé programování v jazyce C pro chemiky (C3220) Statické proměnné a metody, šablony v C++
Pokročilé programování v jazyce C pro chemiky (C3220) Statické proměnné a metody, šablony v C++ Globální konstantní proměnné Konstantní proměnné specifikujeme s klíčovým slovem const, tyto konstantní proměné
VíceProgramování v C++ 1, 17. cvičení
Programování v C++ 1, 17. cvičení výjimky 1 1 Fakulta jaderná a fyzikálně inženýrská České vysoké učení technické v Praze Zimní semestr 2018/2019 Přehled 1 2 Shrnutí minule procvičené látky Binární vyhledávací
VíceStandardní algoritmy vyhledávací.
Standardní algoritmy vyhledávací. Vyhledávací algoritmy v C++ nám umožňují vyhledávat prvky v datových kontejnerech podle různých kritérií. Také se podíváme na vyhledávání metodou půlením intervalu (binární
VíceAbstraktní třídy, polymorfní struktury
Karel Müller, Josef Vogel (ČVUT FIT) Abstraktní třídy, polymorfní struktury BI-PA2, 2011, Přednáška 9 1/32 Abstraktní třídy, polymorfní struktury Ing. Josef Vogel, CSc Katedra softwarového inženýrství
VíceDědění, polymorfismus
Programování v jazyce C/C++ Ladislav Vagner úprava Pavel Strnad Dědění. Polymorfismus. Dnešní přednáška Statická a dynamická vazba. Vnitřní reprezentace. VMT tabulka virtuálních metod. Časté chyby. Minulá
VíceFunkční objekty v C++.
Funkční objekty v C++. Funkční objekt je instance třídy, která má jako svou veřejnou metodu operátor (), tedy operátor pro volání funkce. V dnešním článku si ukážeme jak zobecnit funkci, jak používat funkční
VíceObsah. Předmluva 13 Zpětná vazba od čtenářů 14 Zdrojové kódy ke knize 15 Errata 15
Předmluva 13 Zpětná vazba od čtenářů 14 Zdrojové kódy ke knize 15 Errata 15 KAPITOLA 1 Úvod do programo vání v jazyce C++ 17 Základní pojmy 17 Proměnné a konstanty 18 Typy příkazů 18 IDE integrované vývojové
Vícepřetížení operátorů (o)
přetížení operátorů (o) - pro vlastní typy je možné přetížit i operátory (tj. definovat vlastní) - pro definici slouží klíčové slovo operator následované typem/znakem operátoru - operátor je speciální
VíceJazyk C++ II. STL knihovna kontejnery část 1
Jazyk C++ II STL knihovna kontejnery část 1 AR 2013/2014 Jazyk C++ II STL kontejnery Kontejnery jsou třídy, jejichž instance slouží k uskladňování dat. Každý druh kontejneru má své výhody a nevýhody. Kontejnery
VícePB161 Programování v jazyce C++ Přednáška 9
PB161 Programování v jazyce C++ Přednáška 9 Právo friend Přetěžování operátorů Nikola Beneš 16. listopadu 2015 PB161 přednáška 9: friend, přetěžování operátorů 16. listopadu 2015 1 / 30 Reklama PB173 Tematicky
VícePB161 Programování v jazyce C++ Přednáška 10
PB161 Programování v jazyce C++ Přednáška 10 Šablony Nikola Beneš 27. listopadu 2017 PB161 přednáška 10: šablony 27. listopadu 2017 1 / 33 Šablony PB161 přednáška 10: šablony 27. listopadu 2017 2 / 33
VíceKonstruktory a destruktory
Konstruktory a destruktory Nedostatek atributy po vytvoření objektu nejsou automaticky inicializovány hodnota atributů je náhodná vytvoření metody pro inicializaci, kterou musí programátor explicitně zavolat,
VícePB161 Programování v jazyce C++ Přednáška 10
.. PB161 Programování v jazyce C++ Přednáška 10 Šablony Nikola Beneš 23. listopadu 2015 PB161 přednáška 10: šablony 23. listopadu 2015 1 / 29 K zamyšlení Jaký je rozdíl mezi new int[10] a new int[10]()?
VícePB161 Programování v jazyce C++ Přednáška 3
PB161 Programování v jazyce C++ Přednáška 3 Kontejnery Iterátory Algoritmy Nikola Beneš 4. října 2016 PB161 přednáška 3: kontejnery, iterátory, algoritmy 4. října 2016 1 / 25 Standardní knihovna C++ Už
VícePB161 Programování v jazyce C++ Přednáška 4
PB161 Programování v jazyce C++ Přednáška 4 Přetěžování funkcí Konstruktory a destruktory Nikola Beneš 9. října 2017 PB161 přednáška 4: přetěžování funkcí, konstruktory, destruktory 9. října 2017 1 / 20
VíceMělká a hluboká kopie
Karel Müller, Josef Vogel (ČVUT FIT) Mělká a hluboká kopie BI-PA2, 2011, Přednáška 5 1/28 Mělká a hluboká kopie Ing. Josef Vogel, CSc Katedra softwarového inženýrství Katedra teoretické informatiky, Fakulta
VíceTŘÍDY POKRAČOVÁNÍ. Události pokračování. Příklad. public delegate void ZmenaSouradnicEventHandler (object sender, EventArgs e);
TŘÍDY POKRAČOVÁNÍ Události pokračování public delegate void ZmenaSouradnicEventHandler (object sender, EventArgs e); class Bod private int x; private int y; public event ZmenaSouradnicEventHandler ZmenaSouradnic;
VícePB161 Programování v jazyce C++ Přednáška 4
PB161 Programování v jazyce C++ Přednáška 4 Dynamická alokace Kopírovací konstruktor Přetypování v C++ Nikola Beneš 12. října 2015 PB161 přednáška 4: dynamická alokace, kopírovací konstruktor, casting
VícePB161 Programování v jazyce C++ Přednáška 5
PB161 Programování v jazyce C++ Přednáška 5 Jmenné prostory Vstupní/výstupní proudy Nikola Beneš 19. října 2015 PB161 přednáška 5: jmenné prostory, vstupní/výstupní proudy 19. října 2015 1 / 29 Jmenné
VícePokročilé programování v jazyce C pro chemiky (C3220) Operátory new a delete, virtuální metody
Pokročilé programování v jazyce C pro chemiky (C3220) Operátory new a delete, virtuální metody Dynamická alokace paměti Jazyky C a C++ poskytují programu možnost vyžádat si část volné operační paměti pro
VíceProgramování v C++ 3, 3. cvičení
Programování v C++ 3, 3. cvičení úvod do objektově orientovaného programování 1 1 Fakulta jaderná a fyzikálně inženýrská České vysoké učení technické v Praze Zimní semestr 2018/2019 Přehled Dokončení spojového
VíceOBJEKTOVÉ PROGRAMOVÁNÍ V C++ V PŘÍKLADECH 8 Proudová knihovna 8.1 Hierarchie proudů... 8-1 8.2 Standardně zavedené proudy... 8-1 8.
David MATOUŠEK OBJEKTOVÉ PROGRAMOVÁNÍ V C++ V PØÍKLADECH Praha 2011 David Matoušek Objektové programování v C++ v pøíkladech Lektoroval Ing. Bohumil Brtník, Ph.D. Bez pøedchozího písemného svolení nakladatelství
VíceChování konstruktorů a destruktorů při dědění
Dědičnost V objektově orientovaném programování je dědičnost způsob, jak vytvořit novou třídu použitím již existujících definic jiných tříd. Takto vytvořené třídy přebírají vlastnosti a metody svého předka
VíceÚvod do programovacích jazyků (Java)
Úvod do programovacích jazyků (Java) Michal Krátký Katedra informatiky VŠB Technická univerzita Ostrava Úvod do programovacích jazyků (Java), 2007/2008 c 2006 2008 Michal Krátký Úvod do programovacích
VícePB161 Programování v jazyce C++ Přednáška 7
PB161 Programování v jazyce C++ Přednáška 7 Statické položky tříd Základy OOP Nikola Beneš 6. listopadu 2018 PB161 přednáška 7: static, základy OOP 6. listopadu 2018 1 / 21 Klíčové slovo static Znáte z
VícePB161 Programování v jazyce C++ Přednáška 7
PB161 Programování v jazyce C++ Přednáška 7 Statické položky tříd Základy OOP Nikola Beneš 6. listopadu 2018 PB161 přednáška 7: static, základy OOP 6. listopadu 2018 1 / 21 Klíčové slovo static Znáte z
VíceZákladní datové struktury
Základní datové struktury Martin Trnečka Katedra informatiky, Přírodovědecká fakulta Univerzita Palackého v Olomouci 4. listopadu 2013 Martin Trnečka (UPOL) Algoritmická matematika 1 4. listopadu 2013
VíceProstory jmen. při vkládání několika hlavičkových souborů může vzniknout kolize. logika.h const int x=5; typedef struct {...
Proudy v C++ Jmenné prostory Prostory jmen při vkládání několika hlavičkových souborů může vzniknout kolize zeleznice.h const int x=10; typedef struct {... } Hradlo; logika.h const int x=5; typedef struct
VíceMichal Krátký. Úvod do programovacích jazyků (Java), 2006/2007
Úvod do programovacích jazyků (Java) Michal Krátký 1 Katedra informatiky VŠB Technická univerzita Ostrava Úvod do programovacích jazyků (Java), 2006/2007 c 2006 Michal Krátký Úvod do programovacích jazyků
Vícemap, multimap - Asociativní pole v C++.
map, multimap - Asociativní pole v C++. Jedná se o asociativní pole. V asociativním poli jsou uloženy hodnoty ve tvaru (klíč,hodnota), kde klíč je vlastně "index" prvku. Klíčem může být libovolný objekt,
VíceAbstraktní datové typy
Karel Müller, Josef Vogel (ČVUT FIT) Abstraktní datové typy BI-PA2, 2011, Přednáška 10 1/27 Abstraktní datové typy Ing. Josef Vogel, CSc Katedra softwarového inženýrství Katedra teoretické informatiky,
VíceProgramování v C++ 2, 7. cvičení
Programování v C++ 2, 7. cvičení spojový seznam 1 1 Fakulta jaderná a fyzikálně inženýrská České vysoké učení technické v Praze Zimní semestr 2018/2019 Přehled 1 2 Shrnutí minule procvičené látky Dědění
VíceMichal Krátký. Úvod do programovacích jazyků (Java), 2006/2007
Úvod do programovacích jazyků (Java) Michal Krátký Katedra informatiky VŠB Technická univerzita Ostrava Úvod do programovacích jazyků (Java), 2006/2007 c 2006 Michal Krátký Úvod do programovacích jazyků
VíceVíce o konstruktorech a destruktorech
Více o konstruktorech a destruktorech Více o konstruktorech a o přiřazení... inicializovat objekt lze i pomocí jiného objektu lze provést přiřazení mezi objekty v původním C nebylo možné provést přiřazení
VíceZápis programu v jazyce C#
Zápis programu v jazyce C# Základní syntaktická pravidla C# = case sensitive jazyk rozlišuje velikost písmen Tzv. bílé znaky (Enter, mezera, tab ) ve ZK překladač ignoruje každý příkaz končí ; oddělovač
VícePREPROCESOR POKRAČOVÁNÍ
PREPROCESOR POKRAČOVÁNÍ Chybová hlášení V C# podobně jako v C++ existuje direktiva #error, která způsobí vypsání chybového hlášení překladačem a zastavení překladu. jazyk C# navíc nabízí direktivu #warning,
VíceJazyk C++ I. Šablony 2
Jazyk C++ I Šablony 2 AR 2013/2014 Jazyk C++ I Třídy template class TVektor { T *a; int n; static int PocInstanci; public: TVektor(int _n = 0) : n(_n) { a = new T[n]; PocInstanci++; } ~TVektor()
VíceGenerické programování
Generické programování Od C# verze 2.0 = vytváření kódu s obecným datovým typem Příklad generická metoda, zamění dva parametry: static void Swap(ref T p1, ref T p2) T temp; temp = p1; p1 = p2; p2 =
VíceMnožina v C++ (set, multiset).
Množina v C++ (set, multiset). Množina je datová struktura, ve které jsou uloženy nějaké prvky. V množině nesmí být dva stejné prvky. Naopak multimnožina může obsahovat i stejné prvky. Nad množinou lze
VíceZpracoval: houzvjir@fel.cvut.cz
Zpracoval: houzvjir@fel.cvut.cz 10. Objektově orientované programování v C++. Přetěţování operátorů, generické funkce a třídy, výjimky, knihovny. (A7B36PJC) Obsah OOP v C++... 2 Pro připomenutí - Základní
VíceJazyk C++ I. Šablony
Jazyk C++ I Šablony AR 2013/2014 Jazyk C++ I Úvod Zatím známe programovací styly: Strukturované programování, Objektově orientované programovaní. AR 2013/2014 Jazyk C++ I 2 Příklady void Print(const int&
VícePB161 Programování v jazyce C++ Přednáška 3
PB161 Programování v jazyce C++ Přednáška 3 Kontejnery Iterátory Algoritmy Nikola Beneš 2. října 2018 PB161 přednáška 3: kontejnery, iterátory, algoritmy 2. října 2018 1 / 27 Automatická dedukce typů (od
Více14.4.2010. Obsah přednášky 7. Základy programování (IZAPR) Přednáška 7. Parametry metod. Parametry, argumenty. Parametry metod.
Základy programování (IZAPR) Přednáška 7 Ing. Michael Bažant, Ph.D. Katedra softwarových technologií Kancelář č. 229, Náměstí Čs. legií Michael.Bazant@upce.cz Obsah přednášky 7 Parametry metod, předávání
VíceVirtuální metody - polymorfizmus
- polymorfizmus - potomka lze použít v místě, kde je možné použít předka - v dosud probraných situacích byly vždy volány funkce, které jsou známy již v době překladu. V situaci, kdy v době překladu není
VíceMichal Krátký. Úvod do programovacích jazyků (Java), 2006/2007
Úvod do programovacích jazyků (Java) Michal Krátký Katedra informatiky VŠB Technická univerzita Ostrava Úvod do programovacích jazyků (Java), 2006/2007 c 2006 Michal Krátký Úvod do programovacích jazyků
VíceŠablony funkcí a tříd (Templates) Genericita
Šablony funkcí a tříd (Templates) Genericita Šablony funkcí Motivace přetížíme funkci pro výpočet minima ze dvou hodnot: int minimum(int a, int b) { return (a
VíceProgramování v jazyce C a C++
Programování v jazyce C a C++ Richter 1 Petyovský 2 1. března 2015 1 Ing. Richter Miloslav, Ph.D., UAMT FEKT VUT Brno 2 Ing. Petyovský Petr, UAMT FEKT VUT Brno C++ Stručná charakteristika Nesdíĺı normu
VíceMnožina čísel int stl-set-int.cpp
Řetězce, pole a STL V C++ je výhodné pro práci s řetězci použít třídu string, funkce C jsou stále k dispozici cstring, ukazatele a pole lze stále používat stejně, jako v C, použití iterátorů a dalších
VícePROGRAMOVÁNÍ V C++ URČENO PRO VZDĚLÁVÁNÍ V AKREDITOVANÝCH STUDIJNÍCH PROGRAMECH ROSTISLAV FOJTÍK
PROGRAMOVÁNÍ V C++ URČENO PRO VZDĚLÁVÁNÍ V AKREDITOVANÝCH STUDIJNÍCH PROGRAMECH ROSTISLAV FOJTÍK ČÍSLO OPERAČNÍHO PROGRAMU: CZ.1.07 NÁZEV OPERAČNÍHO PROGRAMU: VZDĚLÁVÁNÍ PRO KONKURENCESCHOPNOST OPATŘENÍ:
VícePolymorfismus. Časová náročnost lekce: 3 hodiny Datum ukončení a splnění lekce: 30.března
Polymorfismus Cíle lekce Cílem lekce je vysvětlit význam pojmu polymorfismus jako základní vlastnosti objektově orientovaného programování. Lekce objasňuje vztah časné a pozdní vazby a jejich využití.
VíceIB111 Programování a algoritmizace. Objektově orientované programování (OOP)
IB111 Programování a algoritmizace Objektově orientované programování (OOP) OP a OOP Objekt Kombinuje data a funkce a poskytuje určité rozhraní. OP = objektové programování Vše musí být objekty Např. Smalltalk,
VíceIterátory v C++. int pole[20]; for (int *temp = pole, temp!= &pole[20]; temp++) { *temp = 0;
Iterátory v C++. Iterátor v C++ je vlastně taková obdoba ukazatelů pro kontejnery. Dříve, než se dostaneme k bližšímu vysvětlení pojmu iterátor, ukážeme si jednoduchý příklad, jak pracovat s obyčejným
VíceProgramování v C++ 2, 8. cvičení
Programování v C++ 2, 8. cvičení návrhový vzor iterátor 1 1 Fakulta jaderná a fyzikálně inženýrská České vysoké učení technické v Praze Zimní semestr 2018/2019 Přehled 1 2 Shrnutí minule procvičené látky
VíceKolekce, cyklus foreach
Kolekce, cyklus foreach Jen informativně Kolekce = seskupení prvků (objektů) Jednu již známe pole (Array) Kolekce v C# = třída, která implementuje IEnumerable (ICollection) Cyklus foreach ArrayList pro
Více<surface name="pozadi" file="obrazky/pozadi/pozadi.png"/> ****************************************************************************
zdroje/zdroje.xml
VíceÚvod do jazyka C. Ing. Jan Fikejz (KST, FEI) Fakulta elektrotechniky a informatiky Katedra softwarových technologií
1 Fakulta elektrotechniky a informatiky Katedra softwarových technologií 12. října 2009 Organizace výuky Přednášky Teoretické základy dle normy jazyka C Cvičení Praktické úlohy odpřednášené látky Prostřední
VíceUkazka knihy z internetoveho knihkupectvi www.kosmas.cz
Ukazka knihy z internetoveho knihkupectvi www.kosmas.cz Upozornění pro čtenáře a uživatele této knihy Všechna práva vyhrazena. Žádná část této tištěné či elektronické knihy nesmí být reprodukována a šířena
VíceJazyk C++ II. Výjimky
Jazyk C++ II Výjimky AR 2013/2014 Jazyk C++ II Funkce abort Dříve byl obvyklý způsob zavolat metodu abort(). Metoda provádí okamžitě: Vyprázdnění vyrovnávací paměti, Ukončení celého programu, Vrátí číslo
Víceint ii char [16] double dd název adresa / proměnná N = nevyužito xxx xxx xxx N xxx xxx N xxx N
Struktura (union) - struktura a union jsou složené typy, které "v sobě" mohou obsahovat více proměnných - struktura obsahuje v každém okamžiku všechny své proměnné, union obsahuje (=je "aktivní") pouze
VíceÚvod Třídy Rozhraní Pole Konec. Programování v C# Hodnotové datové typy, řídící struktury. Petr Vaněček 1 / 39
Programování v C# Hodnotové datové typy, řídící struktury Petr Vaněček 1 / 39 Obsah přednášky Referenční datové typy datové položky metody přístupové metody accessory, indexery Rozhraní Pole 2 / 39 Třídy
VícePřetěžování operátorů
Přetěžování operátorů Cíle lekce Cílem lekce je seznámit se s mechanizmem přetížení operátorů a s použitím tohoto mechanizmu při návrhu a implementaci programů. Po absolvování lekce budete: umět využívat
VíceVstupní a vstupní proudy v C++
Programovací jazyk C++ MZLU - PEF - Ústav informatiky 11. října 2007 Vstup na terminál a čtení z něj Používá se knihovna iostream. Pro výstup lze použít standardní výstup cout. nebo chybový výstup cerr.
VícePB161 Programování v jazyce C++ Přednáška 8
.. PB161 Programování v jazyce C++ Přednáška 8 Výjimky Správa prostředků (RAII) Nikola Beneš 9. listopadu 2015 PB161 přednáška 8: výjimky, RAII 9. listopadu 2015 1 / 24 . PB161 přednáška 8: výjimky, RAII
VícePŘETĚŽOVÁNÍ OPERÁTORŮ
PŘETĚŽOVÁNÍ OPERÁTORŮ Jazyk C# podobně jako jazyk C++ umožňuje přetěžovat operátory, tj. rozšířit definice některých standardních operátorů na uživatelem definované typy (třídy a struktury). Stejně jako
VíceNMIN201 Objektově orientované programování 1 / :36:09
NMIN201 Objektově orientované programování 1 / 26 8.10.2013 15:36:09 Objekty Svět se skládá z objektů! konkrétní x abstraktní hmatatelné x nehmatatelné (letadlo) x (chyba v programu) Objekty mohou obsahovat
VíceJazyk C++ II. STL knihovna kontejnery část 2
Jazyk C++ II STL knihovna kontejnery část 2 AR 2013/2014 Jazyk C++ II Asociativní kontejnery Slovníky u kterých pořadí dat nemá smysl. Kontejner si sám určuje, kam který údaj uloží. Údaje mají tvar klíč/hodnota.
VíceDatové proudy objektový vstup a výstup v C++
Datové proudy objektový vstup a výstup v C++ Petr Šaloun 10. listopadu 2014 PJCPP Objektový vstup/výstup 10-1 Datové proudy objektový vstup a výstup v C++ Základní pojmy Znakje elementární textová informace,
VíceSpojová implementace lineárních datových struktur
Spojová implementace lineárních datových struktur doc. Mgr. Jiří Dvorský, Ph.D. Katedra informatiky Fakulta elektrotechniky a informatiky VŠB TU Ostrava Prezentace ke dni 13. března 2017 Jiří Dvorský (VŠB
VíceStručný obsah První týden Druhý týden 211 Třetí týden 451 Rejstřík 787
Stručný obsah První týden 25 den 1 Začínáme 27 den 2 Anatomie programu C++ 43 den 3 Proměnné a konstanty 57 den 4 Výrazy a příkazy 79 den 5 Funkce 107 den 6 Objektově orientované programování 141 den 7
VíceÚvod do programování. Lekce 1
Úvod do programování Lekce 1 Základní pojmy vytvoření spustitelného kódu editor - psaní zdrojových souborů preprocesor - zpracování zdrojových souborů (vypuštění komentářů atd.) kompilátor (compiler) -
VíceDědičnost. Časová náročnost lekce: 3 hodiny Datum ukončení a splnění lekce: 23.března
Dědičnost Cíle lekce Cílem lekce je naučit se pracovat a využívat dědičnosti při návrhu a tvorbě programů. Lekce je zaměřena hlavně na jednoduchou dědičnost. Bude rovněž vysvětlen rozdíl mezi dědičností
VíceJazyk C++ 1. Blok 3 Objektové typy jazyka C++ Třída. Studijní cíl. Doba nutná k nastudování. Průvodce studiem
Jazyk C++ 1 Blok 3 Objektové typy jazyka C++ Studijní cíl Ve třetím bloku bude představen a rozebrán nejdůležitější objektový typ jazyka C++ a to sice třída. Po absolvování bloku bude student schopen navrhovat
VíceNPRG031 Programování II 1 / :25:46
NPRG031 Programování II 1 / 26 28. 2. 2018 11:25:46 Objekty Svět se skládá z objektů! konkrétní x abstraktní hmatatelné x nehmatatelné (letadlo) x (chyba v programu) Objekty mohou obsahovat jiné objekty
Více18. února 2015, Brno Připravil: David Procházka. Programovací jazyk C++
18. února 2015, Brno Připravil: David Procházka Vstupní a výstupní proudy v C++ Programovací jazyk C++ Vstup dat do programu Strana 2 / 26 Obsah přednášky 1 Vstup dat do programu 2 Terminál 3 Textový soubor
Vícekonstruktory a destruktory (o)
konstruktory a destruktory (o) - slouží k ovlivnění vzniku (inicializace) a zániku (úklid) objektu - základní myšlenkou je, že proměnná by měla být inicializována (nastavena do počátečního stavu) a zároveň
VíceJazyk C++ II. Šablony a implementace
Jazyk C++ II Šablony a implementace AR 2013/2014 Jazyk C++ II Úvod Dědičnost a kompozice nejsou vždy tou správnou odpovědí na požadavky znovupoužitelnosti kódu. Proto máme možnost definování určité třídy
VíceAlgoritmizace prostorových úloh
INOVACE BAKALÁŘSKÝCH A MAGISTERSKÝCH STUDIJNÍCH OBORŮ NA HORNICKO-GEOLOGICKÉ FAKULTĚ VYSOKÉ ŠKOLY BÁŇSKÉ - TECHNICKÉ UNIVERZITY OSTRAVA Algoritmizace prostorových úloh Datové struktury Daniela Szturcová
VíceCvičení z programování v C++ ZS 2016/2017 Přemysl Čech
Cvičení z programování v C++ ZS 2016/2017 Přemysl Čech cíl: vytvořit třídu inf_system pro ukládání informací o studentech a zaměstnancích působících na fakultě příklad použití: int main() { inf_system
VícePB161 6. přednáška (26. října 2015)
PB161 6. přednáška (26. října 2015) Standardní knihovna C++ obsahuje řadu částí, některé už jsme viděli (strings, I/O streams) mimo jiné obsahuje i knihovní funkce ze standardní knihovny jazyka C jiné
VíceDynamicky vázané metody. Pozdní vazba, virtuální metody
Dynamicky vázané metody Pozdní vazba, virtuální metody Motivace... class TBod protected: float x,y; public: int vrat_pocet_bodu() return 1; ; od třídy TBod odvodíme: class TUsecka: public TBod protected:
VíceStandardní algoritmy v C++.
Standardní algoritmy v C++. Standardní algoritmy jsou součástí STL. Jedná se o spoustu užitečných šablon funkcí, které za nás naprogramoval někdo jiný. Na nás je jen, abychom je používali. Také si ukážeme
VíceIUJCE Přednáška č. 11. další prvky globální proměnné, řízení viditelnosti proměnných, funkcí
Velké projekty v C velký = 100ky a více řádek udržovatelnost, bezpečnost, přehlednost kódu rozdělení programu do více souborů další prvky globální proměnné, řízení viditelnosti proměnných, funkcí Globální
Více24-2-2 PROMĚNNÉ, KONSTANTY A DATOVÉ TYPY TEORIE DATUM VYTVOŘENÍ: 23.7.2013 KLÍČOVÁ AKTIVITA: 02 PROGRAMOVÁNÍ 2. ROČNÍK (PRG2) HODINOVÁ DOTACE: 1
24-2-2 PROMĚNNÉ, KONSTANTY A DATOVÉ TYPY TEORIE AUTOR DOKUMENTU: MGR. MARTINA SUKOVÁ DATUM VYTVOŘENÍ: 23.7.2013 KLÍČOVÁ AKTIVITA: 02 UČIVO: STUDIJNÍ OBOR: PROGRAMOVÁNÍ 2. ROČNÍK (PRG2) INFORMAČNÍ TECHNOLOGIE
VíceVector datový kontejner v C++.
Vector datový kontejner v C++. Jedná se o datový kontejner z knihovny STL jazyka C++. Vektor je šablona jednorozměrného pole. Na rozdíl od "klasického" pole má vector, mnoho užitečných vlastností a služeb.
VíceAbstraktní datové typy: zásobník
Abstraktní datové typy: zásobník doc. Ing. Miroslav Beneš, Ph.D. katedra informatiky FEI VŠB-TUO A-1007 / 597 324 213 http://www.cs.vsb.cz/benes Miroslav.Benes@vsb.cz Abstraktní datové typy omezené rozhraní
VíceZákladní pojmy. Úvod do programování. Základní pojmy. Zápis algoritmu. Výraz. Základní pojmy
Úvod do programování Michal Krátký 1,Jiří Dvorský 1 1 Katedra informatiky VŠB Technická univerzita Ostrava Úvod do programování, 2004/2005 Procesor Procesorem je objekt, který vykonává algoritmem popisovanou
VícePB přednáška (23. listopadu 2015)
PB161 10. přednáška (23. listopadu 2015) Šablony Motivace snaha o co nejmenší duplikaci kódu co když máme kód, který chceme použít pro různé typy? generická funkce (maximum, minimum, swap, ) kontejnery
VíceTeoretické minimum z PJV
Teoretické minimum z PJV Pozn.: následující text popisuje vlastnosti jazyka Java zjednodušeně pouze pro potřeby výuky. Třída Zavádí se v programu deklarací třídy což je část programu od klíčových slov
Více1. Programování proti rozhraní
1. Programování proti rozhraní Cíl látky Cílem tohoto bloku je seznámení se s jednou z nejdůležitější programátorskou technikou v objektově orientovaném programování. Tou technikou je využívaní rozhraní
Více