Vaše první aplikace

Vaše první aplikace

V rámci projektu „Cesta k vědě“ (veda.gymjs.net) vytvořil V. Pospíšil ([email protected]) a Antonín Šulc. Modifikace a šíření dokumentu podléhá licenci GNU GPL (www.gnu.org).

##includeinclude <iostream> <iostream>

using using namespacenamespace std; std;

intint main( main(intint countArgs, countArgs,charchar *argch[]){ *argch[]){

cout << "Hello world";cout << "Hello world";

returnreturn 0; 0;

}}

•#include <iostream> udává knihovnu pro vstupy a výstupy•Funkce main je základním vstupním bodem do vašeho programu. Zjednodušeně si lze představit, že váš program funkcí main začíná a končí.•Instance std::cout přijme řetězec Hello world a postará se o jeho vypsání na obrazovku•return 0 říká, že se má funkce ukončit a vrátit hodnotu 0•V případě že bychom chtěli získat vstup z klávesnice použijeme objekt std::cin

Začátek

Chyby ve zdrojovém

kódu?

Sestavení

Kompilace

Editace zdrojového

kódu

Ano

Chyby v sestavování

Spuštění programu

Chyby při běhu

programu

Konec

Ne

mailto:[email protected]

Proměnné


•Syntaxe:Syntaxe: typtyp identifikátoridentifikátor = počáteční hodnota = počáteční hodnota

•Proměnná slouží k uchování hodnot. Je určena rozsahem svých hodnot a Proměnná slouží k uchování hodnot. Je určena rozsahem svých hodnot a přesností – to určuje datový typ v C++ máme několik základníchpřesností – to určuje datový typ v C++ máme několik základních•intint – celé číslo(– celé číslo(signedsigned – se znaménkem, – se znaménkem,unsignedunsigned))

•Rozsah hodnot je 2Rozsah hodnot je 2^63^63•llongong-- celé číslo s větším rozsahem(většinou – záleží na kompilátoru) celé číslo s větším rozsahem(většinou – záleží na kompilátoru)•boolbool–logická hodnota, může nabývat hodnot–logická hodnota, může nabývat hodnot truetrue=1, nebo =1, nebo falsefalse=0=0 •charchar a a wchar_twchar_t – jsou znakové typy, tzn.mohou obsahovat – jsou znakové typy, tzn.mohou obsahovat znak. znak.

•char může obsahovat jeden z ASCII znaků(256 char může obsahovat jeden z ASCII znaků(256 kombinací).kombinací).

•wchar_t je UNICODE, tzn. mezinárodní znaky wchar_t je UNICODE, tzn. mezinárodní znaky •floatfloat a a doubledouble – jsou typy pro ukládání hodnot reálných čísel– jsou typy pro ukládání hodnot reálných čísel

•floatfloat na 7 platných cifer na 7 platných cifer•doubledouble na 15 platných cifer na 15 platných cifer


Proměnné


•Proměnné se ukládají na vrchol zásobníku(TOS) a při definici můžeme Proměnné se ukládají na vrchol zásobníku(TOS) a při definici můžeme přiřadit hodnotu dvěma způsoby,přičemž oba dva jsou ekvivalentní.přiřadit hodnotu dvěma způsoby,přičemž oba dva jsou ekvivalentní.

•intint promenna = 10; promenna = 10;•intint promenna(10); promenna(10);

•Pokud přiřazujeme libovolné proměnné nějakou hodnotu, která je Pokud přiřazujeme libovolné proměnné nějakou hodnotu, která je literál(hodnota zadaná v době programování např.10)literál(hodnota zadaná v době programování např.10), jedná se , jedná se automaticky o konstantu.Např. v předchozím příkladě jsme v obou automaticky o konstantu.Např. v předchozím příkladě jsme v obou případech inicializovali literálem resp. konstantou.Proměnné můžeme i případech inicializovali literálem resp. konstantou.Proměnné můžeme i navzájem přiřazovatnavzájem přiřazovat


Ukázka proměnné


•Chceme vytvořit program,jenž nám získá hodnotu od uživatele a opět jí vypíše.Chceme vytvořit program,jenž nám získá hodnotu od uživatele a opět jí vypíše.

#include#include <iostream> <iostream>


intint pocet_studentu = 0; pocet_studentu = 0;

std::cout << "Studenti:";//výstupstd::cout << "Studenti:";//výstup

std::cin >> pocet_studentu;//vstup z klávesnicestd::cin >> pocet_studentu;//vstup z klávesnice

std::cout <<"Pocet studentu ve tride:" << std::cout <<"Pocet studentu ve tride:" << pocet_studentu;pocet_studentu;

returnreturn 0; 0;

}}

VÝSTUP:VÝSTUP:

Studenti:25Studenti:25

Pocet studentu ve tride:25Pocet studentu ve tride:25


Aritmetické operátory


•Stejně jako v matematice máme aritmetické operátory + , - , * , /. Pro tyto operátory platí stejná pravidla jako v matematice.Např.

•int promenna=9/3;//nyní bude obsah promenna 3•Dále máme operátory inkrementace a dekrementace. Inkrementace znamená zvýšení o 1, dekrementace snížení o 1.Pro obě dvě varianty existuje ještě prefix a postfix.Uvedu příklad:

•int prom1 = 10; // prom1 obsahuje 10

int prom2 = prom1++; // postfix prom2 obsahuje 10 prom1 // se zvýší o 1

•int prom1 = 10; // prom1 obsahuje 10

int prom2 = ++prom1; // prefix prom2 obsahuje 11 stejně // jako prom1

•Existuje také zbytek po dělení, tzv.modulo.Operátor modula má syntaxi op1%op2 .Bude jednodušší si to předvést na příkladu:

•6 % 3 = 0, 6%5 = 1, 13 % 8 = 5,64 % 3 = 1


Bitové operátory


Potřebujeme-li pracovat s jednotlivými bity požijeme k tomu bitové operátory. Máme li proměnnou, můžeme provést s jejím obsahem bitovou konjunkci,disjunkci a nonekvivalenci.

• Bitová nonekvivalence(^)• Daný bit výsledku je roven 1, jsou-li odpovídající bity

různé.Jsou-li shodné, výsledek je 0• 1 ^ 1 = 0, 1 ^ 0 = 1, 0 ^ 0 = 0

• Bitová disjunkce(|)• Daný bit výsledku je roven 1, je-li aspoň jeden z operandů

roven 1, jinak je výsledek 0• 1 | 1 = 1, 1 | 0 = 1, 0 | 0 = 0

• Bitová konjunkce(&)• Daný bit výsledku je roven 1, jsou odpovídající bity obou

operandů rovny 1, jinak je roven 0• 1 & 1 = 1, 1 & 0 = 0, 0 & 0 = 0


Bitové operátory


Představme si proměnnou unsigned short a, jenž obsahuje hodnotu 200, což je hexadecimálně 0xC8, binárně 11001000b a unsigned short b, jenž obsahuje 217 = hexadecimálně 0xD8 = binárně 11011001b

Bitová nonekvivalence a^b

1 1 0 0 1 0 0 0 200

^

1 1 0 1 1 0 0 1 217

0 0 0 1 0 0 0 1 17

Bitová konjunkce a&b

1 1 0 0 1 0 0 0 200

&

1 1 0 1 1 0 0 1 217

1 1 0 0 1 0 0 0 200

Bitová disjunkce a|b

1 1 0 0 1 0 0 0 200

|

1 1 0 1 1 0 0 1 217

1 1 0 1 1 0 0 1 217


Relační operátory


Pokud potřebujeme porovnat nějaké dvě hodnoty resp.proměnné, použijeme k tomu relační operátory. Máme rovnost, nerovnost, větší, menší, větší nebo rovno a menší nebo rovno.

•Rovnost syntaxe: a==b. Pokud má proměnná a stejnou hodnotu jako b, tak je výsledek true, jinak false.•Nerovnost syntaxe: a!=b.Pokud má proměnná a různou hodnotu od b, tak je výsledek true, jinak false.•Menší syntaxe: a<b. Výsledek je true je-li a menší než b•Menší nebo rovno syntaxe: a<=b.Výsledek je true, je-li a menší než b, nebo je-li a rovno b.•Větší: syntaxe:a>b.Výsledek je true, je-li a větší než b •Větší nebo rovno:syntaxe:a>=b.Výsledek je true je li a větší nebo rovno b.


Logické operátory


Logické operátory pracují s proměnnou jako s celkem. Bitové operátory vezmou hodnotu dané proměnné a každý bit vyhodnotí postupně. Předpokládejme opět nějaké dvě proměnné, int a = 10 a int b = 0.Pokud bychom pracovali, pomocí bit.operátorů, např. bitová konjunkce, tzn. a & b, kompilátor by vzal 1010 & 0000 a výsledek by byl 0. Logický operátor vezme hodnotu a pokud je proměnná jakákoli kromě 0, je true.•Logický součin &&(AND)

•Platí pro něj podobná pravidla jako pro bitovou konjunci, tzn., je-li hodnota operandu a jakákoli kromě 0 a b též , je výsledek 1, jinak 0•bool vysledek = a && b; bude 0, jelikož a je sice jakékoli kromě nuly, ovšem b je 0•bool vysledek = a && 1; bude 1, jelikož a je jakékoli od nuly a b je 1.Obsah proměnné výsledek bude 1.

•Logický součet ||(OR)•Platí pro něj pravidla podobná jako pro disjunkci, ovšem s tím, že vezmou o proměnnou a a b, pokud je aspoň jedna proměnná jakákoli od nuly je výsledek 1, jinak 0

•Negace !(NOT)•Pokud je obsah libovolné proměnné 0 je výsledek 1, je-li jakýkoli kromě nuly je výsledek 1.•Syntaxe:!proměnná


Vstupy a výstupy


•Pro vstup a výstup do našeho programu používáme objekty cin a cout, které jsou součástí normy jazyka C++(STL).Pokud se chceme zprostit psaní std:: před každým voláním cin a cout napíšeme hned za #include <iostream> příkaz using namespace std;.

•cout objekt slouží k výstupu na obrazovku.Hodnoty do tohoto objektu posíláme pomocí operátoru << a tento operátor je schopen přijímat všechny standardní typy včetně řetězců(o těch později).Operátor se vyhodnocuje z leva na pravou stranu, a jednotlivé proměnné se oddělují <<.

•cout << prom1 << prom2 << prom_n;//vypíše prom1 //potom prom2 až do prom_n

•cin slouží k přijímání vstupu z klávesnice.Hodnoty z výstupu posíláme pomocí operátoru >> a operátor opět vyhodnocuje z leva do prava.Proměnné oddělujeme >>

•cin >> prom1 >> prom2 >> prom_n;//nahraje vstup do //prom1 potom do prom2 až do prom_n


Podmíněný příkaz


Podmíněný příkaz:

Syntaxe podoba 1:

if(výraz1)

{příkaz1;}

další_příkaz;

Syntaxe podoba 2:

if(výraz1)

{příkaz2;}

else{příkaz2;}•Podoba 1:Je-li výraz1 vyhodnocen jako pravdivý,provede se příkaz1 a pokračuje příkazem další_příkaz.Není-li pravda, příkaz1 ignoruje

•Podoba 2:Vyhodnotí-li se výraz jako pravdivý provede se příkaz1,jinak se provede příkaz2.Potom bude program pokračovat dalším příkazem.


Podmíněný příkaz - příklad


#include <iostream>


int nejakaPromenna = 0;

std::cout << "Zadejte hodnotu promenne";

std::cin >> nejakaPromenna;

if(nejakaPromenna < 10){

std::cout << "Hodnota promenne je mensi nez 10";

}

else{

std::cout << "Hodnota je vetsi, vc.10";

}

return 0;

}


Smyčka while


Syntaxe:

while(podmínka)

{příkaz;}•Když se podmínka vyhodnotí jako pravdivá, provede se příkaz a pak se znovu otestuje podmínka. Je-li pravdivá, provede se příkaz znovu a opakuje se do té doby,než přestane platit podmínka.•continue: Příkaz continue způsobí, že smyčka se vrátí zpět na svůj začátek,tzn.tváří se jako kdyby začal nový cyklus.•break:příkaz break způsobí,že smyčka while okamžitě ukončí svůj běh a pokračuje příkazem za složenou závorkou.Např.:

while(podmínka)

{

if(podmínka2)

break;

příkazy;

}

Zde žádáme aby se cyklus ukončil

break skočí sem a ukončí smyčku


Smyčka do…while


Syntaxe:

do

{příkaz;}while(podmínka);•Provede se příkaz a pak se vyhodnotí podmínka,je-li pravdivá smyčka se zopakuje.V opačném případě smyčka skončí.•Smyčka do…while se používá v okamžiku kdy si chceme být jisti že se tělo smyčky provede aspoň jednou•Např:

char z = 'a';

do{

cout << z << ' ';

z++;

}while(z <= 'z');


Smyčka for


Syntaxe:

for(inicializace;test;akce)

{příkaz;} •Příkaz inicializace se používá většinou k inicializaci stavu čítače, nebo k podobnému úvodnímu nastavení smyčky•test je výraz který se při každém průchodu cyklem testuje je-li pravdivý, provede se příkaz(tělo cyklu) a provede se akce v hlavičce(obvykle zde dojde ke zvýšení hodnoty čítače.•Smyčka do…while se používá v okamžiku kdy si chceme být jisti že se tělo smyčky provede aspoň jednou•Např:

for(int i = 0; i < 10; i++){

std::cout << "Ahoj!";

}

Vypíše desetkrát Ahoj! na obrazovku.


Symčky - příklad


#include <iostream>


int co,na_kolik;

std::cout << "co:";std::cin >> co;

std::cout << "na kolik:";std::cin >> na_kolik;

int vysledek = 1;

for(int n = na_kolik; n > 0; n--){

vysledek = vysledek * co;

}

std::cout << "vysledek" << vysledek;

return 0;

}

•Napište program jenž spočítá n tou mocninu z čísla x


Smyčka for


Syntaxe:

switch(výraz)

{

case prvníHodnota:příkaz1;break;

case druháHodnota:příkaz2;break;

. . .

default:příkaz;break;

}•Příkaz switch umožňuje větvení podle více hodnot výrazu.•Výraz se vyhodnotí a jestliže odpovídá některé hodnotě case, skočí vykonávání na řádek kde se case nachází.•Jestliže neodpovídá ani jedna hodnota skočí(pokud je definován) na příkaz default.•Příaz(y) se vykonávají dokud nenarazí na break, po němž se přesune chod programu za složenou závorku.


Funkce


Syntaxe:Návratový_typ název(typ parametr1,typ parametr2,…,typ parametr_n){

tělo funkce;

return hodnota;

}•Funkce nám umožňují rozdělit program na části, které se vykonají, jen v případě, že danou funkci zavoláme.

•V podstatě rozdělí program na části, které lze vykonávat několikrát, aniž bychom museli opisovat zdrojový kód.

•Funkce vrátí hodnotu typu jenž je typem Návratový_typ.•Všechny proměnné definované v bloku funkce(uvnitř funkce) včetně parametrů jsou lokální proměnné, pro které platí že vzniknou při volání funkce a zanikají když funkce skončí(volání příkazu return)

•Volání má syntaxi:

název(hodnota1,hodnota2,…,hodnota_n);

kde hodnota1 odpovídá parametr1, hodnota2 parametru2 atd.S těmito proměnnými lze manipulovat jako by byli definovány uvnitř funkce.


Funkce - příklad


•Představme si že chceme vypočítat n-tou mocninu x, výpočet mocniny budeme potřebovat ve více bodech naší aplikace, to ovšem obnáší vložit do každého bodu programu cyklus pro výpočet. Proč to tak komplikovat? Můžeme vytvořit funkci, což je posloupnost nějakých příkazů, které jsou vykonány v okamžiku kdy chceme. Pomocí funkcí lze toto implementovat:

int mocnina(int x, int n){

for(int vysl = 1; n > 0; n--)

{

vysl = vysl*x;

};

return vysl; // vrátí výsledek

}

Pokud budeme potřebovat uložit hodnotu výsledku(návratové hodnoty) do nějaké proměnné použijeme jí zkrátka jako operand, tzn.

int vysledek = mocnina(10,3);//obsah vysledek bude 1000

cout << mocnina(2,2); // vypíše na obrazovku 4


Oblast platnosti a viditelnosti


int x = 5;

{ int x = 10;

cout << x; //vypíše 10

{ int x = 15;


}


}// Int x; nelze int x jsme již definovali•Proměnná jenž je definovaná mimo jakákoli blok(funkci,tělo cyklu atd.) je globální proměnná a existuje při běhu celé aplikace.•Oblast viditelnosti je oblast v níž můžeme danou proměnnou používat, začíná od místa její deklarace a končí na konci bloku, nebo souboru•Oblast platnosti je blok(zjednodušeně si lze představit to co je ve složených závorkách {} – tělo cyklu,tělo funkce…)kde proměnná existuje, po opuštění bloku automaticky zaniká.Této proměnné se říká lokální proměnná.

•Proměnná je ve svém bloku nadřazená, tzn.všechny proměnné nadřazených bloků se překryjí.•Po opuštění bloku zanikají

Tato proměnná přepíše proměnnou v

nadřazeném bloku

(ta co obsahuje 10)


Funkce-přetěžování


int funkce(int a); //deklarace funkce

int funkce(char a); //deklarace funkce

int funkce(float a,char);

int main(){

// …

}

int funkce(int a){return a;}// definice funkce

int funkce(char a){return b;}// definice funkce•Funkce lze přetěžovat, tzn. je-li k dispozici více funkcí s různými parametry, tak si kompilátor vybírá mezi vhodnými kandidáty.

•Při volání funkce(10); se zavolá int funkce(int a)•Při volání funkce(‘a‘); se zavolá int funkce(char); •Při volání funkce(0.5,‘a‘) se zavolná int funkce(float,char);

Tato proměnná přepíše proměnnou v

nadřazeném bloku

(ta co obsahuje 10)


Přetypování


Předpokládejme následující funkci:float sin(int angle);

A my máme proměnnou:float uhel = 60.3;•My potřebujeme vypočítat sin(uhel).•Kompilátor dokáže udělat z nějakého typu jiný, pokud je to možné, mnohdy ovšem se ztrátou.V našem případě se typ float proměnné uhel konvertuje v parametru funkce na int, ovšem s tím že „odsekne“ desetinnou část.•To samé platí při inicializaci, int uhel = 30.5;, se konvertuje na celé číslo, tím odsekne(nezaokrouhlí!) a obsah proměnné uhel bude 30•I char se dokáže konvertovat, pokud budeme např.inicializovat,char i = 97.9; tak se 97.9 nejdříve konvertuje na int, takže to bude 97 a poté na char, což představuje v ASCII tabulce znak ‘a‘.•Můžeme si přetypování vynutit explicitně pomocí syntaxe:

(typ_který_chceme)promenná•Výsledek bude proměnná typu typ_který_chceme.• char = (char)98;//bude obsahovat ‘b‘


Pole


Syntaxe:typ identifikátor[počet];

•Pole vytvoří posloupnost proměnných(i v paměti jdou za sebou) určitého počtu.Typ udává typ všech prvků pole, identifkátor je označení daného pole, počet udává počet prvků v poli.•Přístup k prvkům je pomocí indexů v hranatých závorkách:

Identifikátor[index]

•Potřebujeme vytvořit 4 proměnné typu celé číslo, zapíšeme:int pole[4]; a k jednotlivým prvkům přistupujeme pomocí indexů 0,1,2 nebo 3. C++ bere 0 také jako číslo, tzn. 1.prvek má index 0,2. má 1 atd.Tuto posloupnost lze zapsat jako n-1 kde n je prvek ke kterému chceme přistupovat.•Inicializujeme typ indentifikátor[n] = {prvek1,prvek2,…prvek_n}; přičemž se na index 0 nahraje hodnota prvek1, na 1 hodnota prvek2 atd.

–Pokud nedoplníme počet prvků( n ), a doplníme inicializcaci ({…}), kompilátor si sám dokáže odvodit počet prvků

Index:0

Index:1

Index:2

Index:3

Pole 4 prvků


Ukazatele


Syntaxe:typ *identifikátor;

typ *identifikátor = &proměnná;•Ukazatel je proměnná, která obsahuje adresu jiné proměnné nebo funkce.Operátor & vrací adresu proměnné•Kompilátor využívá toho, že každá proměnná má svou adresu v paměti a tím, že ukazatel je proměnná která v sobě uchovává adresu jiné proměnné do sebe nahrává adresu nějakého místa v paměti s kterým může následně manipulovat.•Ukazatel nám umožňuje pracovat s proměnnou umístěnou kdekoli v programu někde jinde. Příkladem může být funkce, kdy jako parametr předáme ukazatel na nějakou proměnnou a pracujeme s touto proměnnou. Proměnná kterou jsme předali v parametru funkce bude měněna.•Dereferencování ukazatele:Potřebujeme-li pracovat s proměnnou jehož adresa je uložena v ukazateli, musíme ukazatel derefencovat, pomocí operátoru * před názvem ukazatele.

Proměnná544

Jiná proměnná

Jiná proměnná

Paměť

Ukazatel0x0004

0x0000

0x0004

0x0008

0x000C


Ukazatele


•Předpokládejme že máme proměnnou floatfloat e = 2.71;// definice proměnné e

float *p_e = &e;

*p_e = 2.7154

std::cout << e; // vypíše 2.7154

•Na tomto příkladu bylo evidentní, že jsme nejdříve vzali adresu proměnné e, nahráli jsme jí do ukazatele p_e a na 3.řádku jsme jeho hodnotu změnili dereferencováním ukazatele.Na obrazovku se odešle hodnota změněné proměnné e•Pole úzce souvisí s ukazateli, protože první prvek pole bez indexu je ukazatel na první prvek

char pole[10];

char *p_pole = pole; // nyní máme adresu prvního prvku pole

char *p_pole2 = &pole[0] // to samé jako v předchozím případě


Řetězce,pole a ukazatele


•Ale lze napsat následující konstrukci.Jelikož řetězec uzavřený v uvozovkách je pole a jak jistě víme, tak oba dva tyto příkazy se nám překonvertují na ukazatel na první prvek pole

char * pole = "ahoj";

char *pole;

pole = "ahoj";•Pro řetězce existují dva způsoby inicializace

–char pole[] = {'A','h','o','j',0}; kde inicializujeme každá prvek zvlášť a nakonec přidáme ukončovací znak, který značí kde řetězec končí–char pole[] = "Ahoj"; je to samé jako předchozí případ, s tím že celý řetězec dáme do uvozovek a poslední ukončovací znak si přidá kompilátor.

•!!!POZOR!!!Nelze ovšem inicializovat posléze, to platí pro pole jakéhokoli typu

char pole[10];

pole = "ahoj";

Aritmetika ukazatelů


•S ukazateli a poli lze provádět některé aritmetické operace.Tato tzv.adresová aritmetika slouží především pro práci s poli pomocí ukazatelů na prvky. •Přičteme-li ukazateli nebo poli celé číslo n posune se ukazatel o n prvků pole dále, takže např.

int pole[6]; int * uk = pole;

*(uk+4) = 3; // je to samé jako pole[4] = 3;

*(pole + 4) = 4;•To samé lze provést s polem.Můžeme použít i inkrementaci a dekrementaci(pouze na ukazatele!)•Překladač ani běžící program nekontrolují zda programátor překročil meze, proto je na to dbát pozor, mnohdy může mít tato chyba dalekosáhlé důsledky.

Prvek 1 Prvek 2 Prvek 3 Prvek 4 Prvek 5 Prvek 6

pole

int pole[6]

pole + 3

Dynamická alokace a dealokace


Syntaxe:typ * ukazatel = new typ;

typ * ukazatel = new typ[počet];

C++ nám umožňuje dynamicky alokovat proměnnou nebo pole. Pokud vytváříme proměnné způsobem typ název vytváříme proměnnou na zásobníku, který je značně omezený. Funkce new vrací ukazatel na nějaké místo v paměti, které se uvolnilo pro vaší proměnnou.new[počet] vrací ukazatel na první prvek pole po velikosti početPracuje dokud je paměť fyzicky v počítači volná(nebo není jiné omezení).Pokud proměnnou resp.její místo v paměti nepotřebujeme měli bychom její místo uvolnit pro jiné programy, nebo proměnné.To lze pomocí operátoru delete, který uvolní místo v paměti.Syntaxe:

delete ukazatel;

delete [] ukazatel;

Pokud paměť neuvolníme zůstane až do restartu celého systému obsazená

Příklad


•Napište program jenž bude inicializovat globální pole pomocí funkce a nakonec jej zobrazí ve funkci main.Pole bude typu int.

#include <iostream>

int pole[] = {0,1,2,3,4};//kompilátor si sám zjistí počet prvků //podle počtu inicializátorů - 5

void napln(int cim){

for(int i = 0; i < 5; i++)

{ pole[i] = cim; }

}

int main(){

napln(10);

for(int i = 0; i< 5; i++)

{ std::cout<<i<<":"<<pole[i]<<'\n'; }

return 0;

}


Příklad


•Napište program pomocí funkce prohodí dvě proměnné,ovšem bez toho aniž bychom museli nějakou proměnnou sdílet globálně

#include <iostream>

void swap(int *a,int *b ){

int pom = *a;

*a = *b;

*b = pom;

}

int main(){

int x1, x2;

x1 = 14;x2 = 3;

swap(&x1, &x2);

return 0;

}

Výčtový typ


Syntaxe:enum jmenovka {

položka_1 = inicializátor,

…,

položka_n};• Jmenovka představuje název daného výčtového typu,ve složených závorkách jsou jednotlivé položky, přičemž pokud nepřidělíme první položce nějakou hodnotu přidělí se jí automaticky 0 a každé další o o hodnotu větší,takže položka_n bude zastupovat číslo n - 1•Výčtové typy pomáhají vyjádřit v programu skutečnosti které stačí popsat pouze celými čísly,ale u nichž potřebujeme omezit rozsah přiřaditelných hodnot.•Výčtovým typem nám vznikne nový typ, do kterého můžeme přiřazovat celá čísla, nebo výčty(položky)•Např.dny v týdnu bychom mohli napsat jako 1-7,nebo lépe pojmenovanými konstantami s uvedenými hodnotami,takže

enum tyden {PO = 1,UT,ST,CT,PA,SO,NE};

Výčtové typy


Budeme k tomu potřebovat výčtový typ, který si můžeme nadefinovat následovně:

enum tyden{po = 1,ut,st,ct,pa,so,ne};

Napište program s jednou funkcí, která přijme parametrem výčtový typ který má definované dny v týdnu a vypíše den v týdnu na obrazovku.

A ještě funkci která bude mít deklaraci:

void vypisDen(tyden data);

Modulární programování


•Pro zjednodušení našich programů, je zvykem, oddělovat definice a deklarace od funkcí. •Deklarace se dávají do hlavičkových souborů a přidávají se pomocí příkazu #include "soubor.h“.Deklarace informují překladač a soubor kde jsme vložili soubor pomocí include o tom že někde existuje nějaká funkce.Definici si dokáže kompilátor najít(pokud ovšem existuje).•Definice se dávají do souborů s příponou cpp,c nebo cxx a není vhodné je vkládat jako hlavičkové soubory, protože může existovat maximálně jedna definice nějaké funkce nebo proměnné//Soubor druhaMocnina.h

#include <iostream>

int druhaMocnina(int x);

//deklarace

//Soubor druhaMocnina.cpp

#include "druhaMocnina.h"

int druhaMocnina(int x){

return x*x;}//definice

//Soubor main.cpp s hlavní funkcí main

#include "druhaMocnina.h"

int main(){}


Modulární programování


y.obj

export c

x.c#include "y.h"double A() {}

y.c#include "y.h"int c;

y.h

extern int c;

extern int c;double A() {}

extern int c;int c;

x.objimport c export A

Formátovaný vstup a výstup


•Funkce pro formátový vstup a výstup jsou v knihovně stdio.h.Proud může být zdrojem nebo cílem dat a může být spojen s diskem,nebo jiným periferním zařízením.

•Pro vstup z klávesnice použijeme funkci scanf(char[], argument,...)–V prvním parametru zadáváme opět řídící řetězec, v dalších parametrech předáváme adresy proměnných do kterých se mají nahrát hodnoty přijaté z klávesnice. Pro získání adresy použijeme operátor &, který nám vydá adresu dané proměnné.

–Např. scanf("%d%d", &i, &j); // Načte 2 čísla, může být i //odděleně

•Pro výstup na obrazovku použijeme funkci printf(char [], argument, …)–V prvním parametru zadáváme řídící řetězec,podle čeho kompilátor pozná jaký typ má zobrazit,případně řetězec.Funkce podporuje libovolný počet parametrů.

–Např. printf("nejaky_int: %d, nejaky_float:%f, nejaky_char[]:%s",nejaky_int,nejaky_float, nejaky_char);

•Vypše:nejaky_int: 10, nejaky_float:10.3, nejaky_char:ahoj




#include <stdio.h>

int a,b,c;

int main(int argc, char *[]){

printf("a+b, zadejte a:");

scanf("%d", &a);

printf("zadejte b:");

scanf("%d", &b);

c = a + b;

printf("%d + %d = %d", a,b,c);

return 0;

}

Výstup:

a+b, zadejte a:10

zadejte b:-5

10 + -5 = 5




Řetězec Data

%c Znak

%d signed int

%ld signed long

%u unsigned int

%lu unsigned long

%f float

%x Hexadecimální(1a2c)

%s Řetězec


Souborový vstup a výstup


•Pro zápis souborů budeme potřebovat knihovnu stdio.h,tu přidáme příkazem #include<stdio.h>.Pro otevření souboru, použijeme strukturu:•FILE *soubor = fopen(“název“,“modifikátor“);•Nyní nahrajeme do ukazatele soubor tzv.deskriptor souboru.Funkce fopen nám poslouží k získání tohoto potřebného ukazatele. název je jméno souboru s kterým budeme pracovat a modifikátor je řetězec jenž udává zda se bude jednat o čtení,zápis nebo obojí.•Pro práci se soubory použijeme funkce

–fgetc(FILE *stream); která vrátí znak z místa kde je momentálně kurzor.V případě že se jedná o konec souboru vrátí speciální hodnotu EOF, což charakterizuje konec souboru–fputc(int znak, FILE *stream); vloží znak na místo kde se momentálně nachází kurzor

•Obě dvě funkce automaticky posouvají kurzor na další pozici.



Modifikátory funkce fopen(“název“, „“modifikátory“);

r otevření textového souboru pro čtení

w vytvoření textového souboru pro zápis,existuje-li tento soubor je jeho původní obsah zahozen

a přepisování – otevře nebo vytvoří(v případě že neexistuje) soubor pro zápis na konec souboru

r+ otevře textový soubor pro aktualizaci(čtení nebo zápis)

w+ vytvoří textový soubor pro aktualizaci,zahodí předchozí obsah, existuje-li

a+ připojení – otevře nebo vytvoří textový soubor pro aktualizaci,zapisuje za konec souboru

Documents

Vaše první aplikace