Jazyk C – základní informace

Vlastnosti

- Univerzální strukturovaný programovací jazyk - Jazyk nižší úrovně � používá jen standardní jednoduché datové typy - Neumožňuje přímou práci s řetězci, poli, vstup a výstup – vše je řešeno

přes funkce - Vysoce efektivní kód - Snadná přenositelnost zdrojových programů na různé procesory i OS - Navržen a implementován pro/s UNIXem - Existuje spousta překladačů

Historie

- 1972 – původní C – K&R – Kernighan and Ritchie - 1978 - Kernighan and Ritchie: The C programming language - 1989 – ANSI C – americký standard pro C – přesně definuje jazyk C i

překladače a standardní sadu hlavičkových souborů a knihoven - 1990 – ISO C90 – mezinárodní norma - 1999 – ISO C99 – novější norma

Princip p řekladu

Zdrojový kód napsaný v editoru „.c“ je společně s hlavičkovými soubory „.h“ zpracován preprocesorem. Compiler (překladač) pak takto zpracovaný výstup převede do relativního kódu „.obj“. Linker následně připojí knihovny, upraví adresy na absolutní a vytvoří spustitelný EXE soubor.

Jazyk C – popis

První program:

- struktura zdrojového kódu - úprava zdrojového kódu - prvky zdrojového kódu

/* soubor hello.c */ #include <stdio.h> /* vlozeni rozhrani */ int main(void) {

printf(”Ahoj!\n”); return 0;

} pozn. system("PAUSE");

Identifikátory Představují názvy proměnných, konstant, funkcí, maker, ….

- case sensitive - omezená délka 31 (63) ale někdy podle kompilátoru i méně - dovoleny jsou klasické znaky (písmena, čísla, _, …)

Klíčová slova Řídí provádění programu (if, while, for, …) Existuje celá řada klíčových slov

Komentá ře Do poznámek:

- popis (vysvětlení) co část kódu provádí - minimálně popis u hlavičky funkcí - části kódu, které nechceme zrovna překládat

/* klasická C poznámka */ // ISO C99 poznámka do konce řádku

Jednoduché datové typy void - prázdný datový typ char - znak short - krátké celé číslo int - celé číslo (podle registru procesoru) long - dlouhé celé číslo float - reálné číslo double - reálné číslo – vyšší přesnost + další typy: long long int, long double, … Modifikátory: unsigned / signed Rozsah hodnot: char - 1B � 0 – 255 (-128 - +127) int - podle architektury 4B, 2B float - 4B + 6B přesnost (za des. čárkou) … Př.: Zjištění velikosti přidělené paměti pro datový typ: sizeof(int);

Př.: Zápis proměnné konkrétního typu a konstanty int pocet; int promena1, promena2; int velikost=15; const char pismeno=‘a‘; Pozn.: vytvoření vlastního jména typu: typedef int LENGTH;

Operátory Definují jednotlivé operace ve výrazech: +, - *, /, &&, ||, =, ==, <>, <=, ……., %, !, ….. atd. Operátory se mohou chovat různě vzhledem k použitým operandům (jejich typům) např. dělení (celočíselné a reálné)

Literály

- celočíselné 5, -564, 06 (osmičkové), 0x5E (šestnáctkové) Poslední znak v literálu L, LL, U, … určuje typ – long, long long, unsigned, …

- reálné

5.75, -2e+9, … Standardně double, přípony L, F (long double, float)

- znakové

‘a’ Znaky, které mají v C speciální význam nutno zapsat pomocí \ (escape sekvence) \n, \t, \\, \”, ……, \x0A

- řetězce „string“ Každý řetězec končí znakem \0 – NUL

Výrazy a práce s prom ěnnými int i; - DEKLARACE i=5; i=5+5; i=5*i; i=(5+i)*i; i++; i=i+5; /* nebo zkráceně i+=5; */

- každý příkaz končí ; - identifikátor (proměnná) musí být nejprve deklarována než je použita - globální identifikátor X lokální X formální parametr funkce

int x=10; int main() {

double x=1.1; /* ve funkci platí double x */ printf(”%f”,x); return 0;

} void printxy(int y) { /* zde platí int x a parametr funkce y*/

printf(”%d”,x); printf(”%d”,y);

}

Hlavní program – funkce main()

- hlavní funkce – musí v programu být - defaultní typ int

int main() { // název funkce a její typ return 0; // návratová hodnota }

NEBO int main(int argc, char *argv[]) { // dva parametry funkce main return 0; }

Standardní knihovny podle ISO C

Knihovny (hlavičkové soubory) obsahují definice typů, maker, funkcí, proměnných. Připojení #include <stdio.h> #include “soubor.h” // dovoz rozhraní modulu z vlastního souboru

Terminálový výstup a vstup Znak: getchar(); // vrací načtený znak ze stdin getc(stdin); putchar(); // zapíše znak na stdout, vrací znak nebo nelze-li zapsat EOF putc(c,stdout) Pozn.: Při spouštění programu lze přesměrovat stdin i stdout do/ze souboru program.exe <vstup.txt >vystup.txt EOF je hodnota (makro) určující konec souboru - 26D Formátovaný vstup a výstup: printf(); Tisk řetězce na stdout. př.: printf(“Výsledek je %d”,vysledek); Za znakem % může být celá řada specifikací, které říkají formát výpisu: %d - celé desítkové číslo %c - znak %f - float %s - řetězec %x - hexa číslo atd…

%5.2lf - long float 5 míst a 2 desetinná scanf(); Formátované čtení ze stdin. scanf(“%d”, &cislo); Použití zápisu % podobně jako u printf. & - značí adresu proměnné Můžeme načítat více hodnot současně. Pozn. %*d - * potlačí přiřazení Př.: Napište program, který vyzve uživatele k zadání dvou čísel a vypíše je i jejich součet. Př.: Napište program, který načte 3 reálná čísla a vypíše jejich průměr na 2 desetinná místa.

Booleovské výrazy využití typu int – 0 – TRUE (PRAVDA) – jinak FALSE (NEPRAVDA) operátory ==, !=, &&, ||, !, <, <=, >, >= Pozn. Standardně se využívá zkrácené vyhodnocování výrazů Př. (y!=0) && (x/y <5) // OK Pozn.: pozor na priority jednotlivých operátorů (pokud si nejsme jisti závorkujeme) aritmetické > porovnávací > logické

Řídící struktury

if a if-else v závislosti na splnění či nesplnění podmínky je nebo není provedena určitá část kódu. Složený příkaz je nutno zavřít do závorek {}. Vyhodnocovaný výraz musí být vždy uzavřen v závorkách (). if (výraz) příkaz; if (výraz) { blok příkazů } if (výraz) příkaz1; else příkaz2; CYKLY

- každý cyklus musí někdy skončit – ukončovací podmínky - obecně lze různé typy cyklů zaměňovat, volba závisí na programátorovi

cyklus while testuje podmínku před začátkem cyklu. cyklus tedy vůbec nemusí proběhnout. V těle cyklu je příkaz nebo blok příkazů {}, event. i prázdný příkaz ; while (x<10) příkaz; cyklus do-while podmínka se testuje až na konci cyklu a cyklus tak proběhne minimálně jednou. Cyklus se opouští při nesplněné podmínce.

do { i++ } while (i<10); cyklus for Pokud známe předem počet průchodů cyklem používáme for. Nevhodné měnit řídicí proměnou kdekoliv v těle cyklu. for (i=1; i<=10; i++) { printf(“%d”,i); } příkazy break a continue break; - ukončuje neuzavřenou vnitřní smyčku – ukončí cyklus continue; - skočí na konec smyčky a spustí další iteraci cyklu Př.: Napište program, který načte číslo značící limit jako požadavek ze stdin, toto číslo uložte. Program pak v cyklu čte čísla a sčítá je dokud nenačte číslo 0. Program porovná součet čísel s uloženým limitem a vypíše výsledek porovnání a výsledek součtu načtených čísel. příkaz switch využívá se pro mnohonásobné větvení dá se nahradit kombinací a vnořováním if-else rozhodovací podmínka musí být int každá větev ukončena příkazem break; a příkazy v ní není nutno uzávorkovávat {} větev default (nepovinná) se provádí pokud žádná podmínka nevyhovuje switch(getchar()) { case ‘a’:

putchar(‘1’); break;

case ‘b’: putchar(‘2’);

break; default: break; } příkaz goto používat pouze ve výjimečných případech nazev: … goto nazev;

podmíněný výraz podmínka ? výraz1 : výraz2 Př. c = (c >=’A’ && c<=’Z’) ? c + (‘a’ – ‘A’) : c; 65 (41H) ‘A’ …. 97 (61H) ‘a’ … operátor čárky výraz1, výraz2 vyhodnotí jako první (zde zaručeno!) výraz1 a pak výraz2 Používat pouze v řídících částech cyklů apod. Př.: for (i=1, j=10; i<=LIMIT; i++, j++) Př.: Napište program, který čte znaky ze stdin (můžete přesměrovat soubor) dokud nedojde na EOF a pak vypíše počet řádků, znaků a písmen a spočte průměrný počet znaků ve slově a znaků na řádku a vypíše.

FUNKCE

� Jakýkoliv jen trochu větší program se prakticky neobejde bez používání funkcí.

� definice – kompletní specifikace vč. typu i s alokací paměti – u funkce

určuje jak hlavičku tak tělo funkce

� minimálně jedna funkce: main()

� v těle funkce nemůže být definice jiné funkce int secti(int a, int b) { return (a + b); } …… vysledek = secti(5,x); ….. pokud je typ funkce void – funkce nic nevrací – jedná se o proceduru (return pak obsahuje jen pro nucené ukončení) Funkce je použitelná (volatelná) až za její definicí. Jinak je nutné uvést „funkční prototyp“ – tj. hlavička funkce v oblasti globálních proměnných: int secti(int a, int b); // úplný funkční prototyp Pozor na oblasti platnosti všech identifikátorů v programu !!! Př.: Napište program, který vypíše faktoriály čísel od 0 do 12

K vlastnímu výpočtu faktoriálu napište funkci factorial() Zkuste zapsat rekurzivní i nerekurzivní variantu. Pozor na rozsah typů, které použijete

(popř. testujte přetečení a při chybě vracejte 0)

Statická Pole jednorozměrná pole int x[pocet]; double d[3] = {5.5, 3.5, 2.0 }; Prvků v poli je vždy 0 až počet-1 !!! Počet musí být znám již v době překladu. Pozor C nekontroluje meze polí !!! – pozor na indexaci. x[i] = 15; vícerozměrná pole int x[6][5]; // jedná se o „pole polí“ - matice Statický řetězec – string char retezec[10] = „text“; řetězec končí vždy znakem ‘\0’ řetězec nelze přiřazovat: str = „text“; Pozn.: char *retezec = „text“; čtení a výpis řetězce: scanf(“%s”, s1); pozor není zde &s1 !!! Načte řetězec (končí prázdným znakem tj i mezera !!!) do s1 pozor na přetečení pole (řetězce) Př. scanf(“%1s”, s1); // načte jeden znak printf(“%s”,s1);

funkce pro práci s řetězci gets(); strlen(); strcpy(); strcat(); strchr(); strcmp(); …… atd atoi(); atoll(); …. sprintf(); sscanf(); Př.: Napište funkci Strcmp

int StrCmp(const char *s1, const char *s2); která lexikálně porovná dva ASCII řetězce. Výsledek funkce je definován takto:

<0: s1 < s2 0: s1 = s2 >0: s1 > s2 Př.: Napište program obsahující pevně danou definici matice 6 x 6. Tmat M = { {1}, {2,2}, {3,3,3}, {4,4,4,4}, {5,5,5,5,5}, {6,6,6,6,6,6}, }; Program obsahuje tři funkce. Provede tisk, tisk transponované, a tisk otočené:

void tiskmatice(const Tmat M); void transpon(Tmat M); void otoc(Tmat M);

Struktura a výčtový typ struktura – varianty zápisu struct { polozky; } nazev_promenych;

struct nazev_s { polozky; }; struct nazev_s promena; typedef struct nazev_s { polozky; } NAZEV_S; NAZEV_S promene; promena.polozka = hodnota;

Výčtový typ typedef enum { PO, UT, ST, CT, PA } DNY; DNY den; den=PO; Prvky mají hodnoty 0, 1, 2, … nebo jim můžeme hodnotu přiřadit PO=5,

Souborový vstup a výstup Načítání rozsáhlých dat z klávesnice a jejich výpis na monitor je často nepoužitelný, proto se používají soubory. Také je často potřeba ukládat perzistentní data pro běh programu. Kromě přesměrování stdin a stdout (viz. výše) můžeme se soubory pracovat přímo. FILE *soubor; // definice proměnné soubor (pointer na objekt FILE) pozn.: pro zápis a čtení používat odlišné identifikátory

Před prací se souborem je třeba jej otevřít: soubor = fopen(“NAZEV_SOUBORU”,”REZIM_OTEVRENI”); fopen() vrací NULL při nesprávném otevření souboru – vždy testovat ! Režimy otevření: r, rb - čtení a čtení binárního souboru w, wb - zápis a zápis binárního souboru a, ab - připojení a připojení k binárnímu souboru (jsou možné i kombinace) Př.: const char *name = ”test.txt”; FILE *fp; fp = fopen( name, ”r” ); if( fp == NULL )

error(”soubor %s nelze otevrit pro cteni”, name); Uzavření souboru: fclose(soubor); // vrací EOF pokud se nepodaří uzavřít Pozn.: Standardně jsou již otevřeny tři io proudy dat (soubory): FILE *stdin, *stdout, *stderr; (pozn.: je možné přiřazení např.: fw = stdout; ) Funkce pro práci se souborem: znak = getc(soubor); //precte znak putc(znak, soubor); //zapise znak

fscanf(soubor,”data”, argumenty), fprintf(soubor,”data”, argumenty) ungetc(c, soubor) Konec souboru: - testovat přes symbolickou konstantu EOF if ((c=getc(fr)) != EOF) …. int main(int argc, char *argv[]) argc – počet argumentů při spuštění programu argv – pole řetězců (vlastní argumenty) Př.: Napište program který odstraní komentáře v C zdrojovém souboru - program očekává 2 parametry: vstupní a vystupni soubor - pokud má jen 1 parametr – jedná se o vstupní a jako výstupní použije „out.txt“ - pokud nemá žádný parametr – očekává zápis z klávesnice a výpis na monitor

- čte ze souboru dokud nenarazí na jeho konec - vypisuje to co načte, ale odstraní komentáře

o oba typy komentářů o pozor na řetězce a znakové konstanty o implementujte konečný automat nebo řešte intuitivně

Ukazatele int *px = NULL; // deklarace ukazatele int x,y; // proměnné typu int px = &x; // & - získá adresu a * zpřístupní hodnotu y = *px; Při „klasickém“ volání funkce se předávají parametry hodnotou. S využitím ukazatelů můžeme předávat parametry odkazem: void prohod(int *px, int *py) {

int temp = *px; *px = *py; *py = temp;

} int x,y; ........ prohod(&x,&y); v praxi je třeba často přidělovat (a uvolňovat) paměť dynamicky: malloc(); free();

Abstraktní datové typy: Seznam: ke každému prvku lze určit jediný bezprostředně následující prvek; je definován jeden z prvků, který je aktivní (pokud takový prvek není, celý seznam je neaktivní). Seznam může dále být jednosměrný, obousměrný nebo kruhový Zásobník: LIFO (last in first out) s definovanými operacemi Push, Pop, Top, IsEmpty Fronta: FIFO (first in first out) QueUp, First, Remove, … může být oboustranně ukončená Pole: náhodný přístup, počet prvků je předem stanoven (statické pole) nebo se mění (dynamické pole) Tabulka: vyhledávací tabulka, každá položka má klíč a hodnotu

Stromy: mají kořen a listy, nejjednodušší je binární strom. BS je buď prázdný nebo se sestává z vrcholu a levého a pravého podstromu. Oba podstromy mají vlastnosti BS. (rekurzivní definice) Př.: (zásobník) typedef struct tzasobnik { char name[100]; struct tzasobnik *pre; // ukazatel na predcho zi

// vklada se vzdy na TOP } tZASOBNIK; tZASOBNIK *top, *act, *zas; // ukazatele na z asobnik

top=NULL; //VKLADANI if ((zas = (tZASOBNIK *) malloc(sizeof(tZASOBNIK))) == NULL) fprintf(stderr,"Malo pameti \n"); strcpy(zas->name,ctk); // vytvori novy a ulozi tam nazev zas->pre=top; // predchozi je ten co byl na TOP top=zas; // TOP je ted ten novej //PROCHAZENI for(act=top; act != NULL; act=act->pre){ ……… }

Základní algoritmy pro řazení a vyhledávání Řazení Hodnotící kritéria :

� stabilita: metoda je stabilní, pokud zachovává relativní pořadí prvků se stejným klíčem

� přirozenost: metoda je přirozená, pokud nejkratší dobu trvá seřazení již seřazeného pole, potom náhodně seřazené pole a nejdelší je opačně seřazené pole

� in situ: pracuje najednou se všemi prvky pole (bez rekurze), používá jen řazené pole (a žádné další)

Straight selection sort: nestabilní Část pole od 1 do K je již seřazena. Minimální prvek z části od K+1 do N se vymění s K+1. prvkem. Na začátku je seřazená část pole prázdná Bubble sort: stabilní a přirozená, vhodná na testování, zda je pole seřazené

Neseřazená část pole se prochází zprava doleva a porovnávají se postupně každé dva sousední prvky pole. Nejsou-li vzájemně seřazeny, tak se vymění. Tímto způsobem vybublá na nejlevější pozici minimum a i ostatní prvky se posunou ke svým správným pozicím. (existuje spousta variant a modifikací základního algoritmu)

Quick sort: nestabilní, nepřirozená, nepracuje in situ Rozdělí pole na dvě části, ve kterých platí, že všechny prvky první části jsou menší než prvky ve druhé části.

int poleA[10]; Qsort(poleA,0,9); int Qsort(int pole[],int d,int h) { int i,j; int x,z; i=d;j=h;x=pole[(int)((d+h)/2)]; do { while (pole[i]<x) i++; while (pole[j]>x) j--; if(i<=j){ z=pole[i]; pole[i]=pole[j]; pole[j]=z; i+=1; j-=1; } }while(i<=j); if(d<j) Qsort(pole,d,j); if(i<h) Qsort(pole,i,h); return 0; }

Další algoritmy: HeapSort (využití stromové struktury), MergeSort, RadixSort, …

Vyhledávání Sekvenční vyhledávání: sekvenčně se prochází všechny prvky. Nesekvenční vyhledávání v seřazeném poli

Binární vyhledávání: na principu metody půlení intervalů Fibonacciho vyhledávání: nedělí interval na poloviny, ale podle hodnot Fibonacciho posloupnosti, ke kterým stačí aditivní operace (rychlejší) …

Binární vyhledávací strom: binární uspořádaný strom, pro jehož každý uzel platí, že jeho levý podstrom je buď prázdný, nebo sestává z uzlů, jejichž klíče jsou menší než jeho, podobně i pro pravý podstrom. Při průchodu INORDER v BVS získáme seřazený lineární seznam.

Moduly a vkládání souborů Program můžeme rozdělit do několika souborů .c. Společnou část pak tvoří rozhraní uvedené v souboru .h (hlavičkový soubor) který obsahuje jen externí deklarace funkcí, proměnných apod. využitelných ve všech souborech do kterých se vkládá. Správné sestavení programu zajišťuje integrované vývojové prostředí nebo třeba makefile.

C++

- jazyk vyšší úrovně - podpora abstraktních datových typů - vychází z C � zpětná kompatibilita - objektová orientace - …

#include <iostream> int main() { std::cout << ” Hello! \n”; // tisk retezce }

OO přístup (Objektově orientovaný přístup):

V objektově orientovaném přístupu uvažujeme o organizaci software jako

kolekci diskrétních objektů, které zahrnují jak data tak i jejich chování.

Důležitým pojmem je „Objekt“. Existuje mnoho různých definicí objektu, ale

všechny mají několik základních podobných rysů.

Objekt můžeme definovat jako reálnou „věc“ nebo její abstrakci. Z pohledu

programátora se jedná o abstrakci, která reprezentuje reálnou věc. Každý objekt

má svoji jednoznačnou identifikaci v daném systému. Objekt zahrnuje řadu dat a

operací nad nimi. Objekt je vůči okolí uzavřený, s lokálními daty pracují lokální

metody. Komunikace mezi dvěma objekty se odehrává prostřednictvím zpráv.

Objekt na příchozí zprávu reaguje zpuštěním vlastní metody, která provádí

určitou činnost s daty objektu, nebo posílá zprávu dalšímu objektu.

Celý softwarový systém je pak tvořen řadou objektů, mezi nimiž existují přesně definované vztahy.

Zpráva 1 Zpráva 2 Zpráva 3 … Zpráva n

Metoda 1

Metoda 3

Met

od

a 2

Met

od

a 4

Seznam zpráv, které je možné objektu poslat

Metody – posloupnosti kódu vykonávajícího činnost

Odkazy na jiné objekty

Lokální data – hodnoty atributů určují stav objektu

Pro usnadnění vývoje objektově orientovaných systémů byl zaveden pojem

třída. Třída popisuje vlastnosti objektu. Definuje tedy vnitřní strukturu objektu.

Každý objekt odvozený od konkrétní třídy bude mít stejný typ a počet atributů i

metod. Objekt potom můžeme definovat jako instanci jeho třídy. Stav, v jakém

se objekt nachází, však není dán třídou, ale provedenými operacemi, tedy

hodnotami jeho atributů.

Zaměstnanec

JménoPříjmeníRČAdresaTelefonPracovní zařazení

vypiš informace()přidej()odeber()uprav údaje()

Základní vlastnosti OO přístupu:

- Zapouzdření (viditelné je pouze rozhraní, podrobnosti implementace nás nezajímají)

- Dědičnost

(objekty – často mívají společné vlastnosti a mohou je dědit – odpadají tak zbytečné redefinice)

- Abstrakce (zavedením abstraktních tříd můžeme lépe využít dědičnosti …)

- Vztahy mezi objekty (dynamické – předávání zpráv mezi objekty X statické – asociace, generalizace/specializace a agregace)

- Polymorfismus (jedna operace provádí jinou činnost pro různé typy objektů)

Př.: (diagram tříd - UML)

Agregace

Generalizace

Atributy

Operace

Pojmenování asociace

Role

Násobnost

Zodpovědnost

class T { // data (i jiné objekty) int i; // metody void m(); // specifikace pristupovych prav private: // definice vnorenych typu, trıd, konstant, ... typedef int typ;

}; Přístupová práva mohou být: public, private, protected class T {

int i; // class => implicitne private public:

int j; // public protected:

int k; // protected public:

int l; // public int m;

};

Př.: class FPS // Trida FPS { private:

unsigned int stary_cas; unsigned int aktualni_cas; double fps; // Pocet snímku za sekundu

public: void Vypocet(); // funkce pro výpo čet fps inline double GetFPS()

{ return fps; }

};

void FPS::Vypocet() { aktualni_cas = SDL_GetTicks();

// Vrátí milisekund od inicializace SDL fps = 1.0 / ((aktualni_cas - stary_cas) / 1000.0 ); stary_cas = aktualni_cas; } FPS fps;// Objekt tridy /* POUŽITÍ*/ fps.Vypocet(); // Aktualizace FPS aktual_fps = fps.GetFPS();