Algoritmizace a programování

Prezentace na téma: "Algoritmizace a programování"— Transkript prezentace:

1 Algoritmizace a programování
Cvičení Jan Kordas D400 2008

2 Obsah cvičení Kompilátor jazyka C. Seznámení s vývojovým prostředím. První program v jazyce C. Základní datové typy a konstanty. Operátory.  Konverze typů. Terminálový vstup/výstup. Větvení (if, switch). Cykly. Příkazy break, continue, goto. Bloky příkazů. Funkce. Viditelnost proměnných. Rekurze. Operátor "čárka". Ternární operátor. Paměťové třídy. Typové modifikátory. Pole. Ukazatele. Dynamicky alokovaná paměť. Struktury. Výčtový datový typ. Union. Bitová pole. Soubory. Knihovny standardních funkcí. Dynamické datové struktury.

3 Materiály Soubor materiálů k přemětu
Webové stránky ke cvičení Cvičení z minulých let Doporučená literatura HEROUT, P.: Učebnice jazyka C ŠALOUN, P.: Programovací jazyk C pro zelenáče BABUŠIAK, B., GÁLA, M.: Programovací jazyk C v príkladoch pre biomedicínskych technikov

4 Hodnocení cvičení Miniprojekt 3x5  bodů (do , 6.11., ) Závěrečný projekt  bodů (do )   Maximum za zápočet  bodů Podmínka pro úspěšné absolvování 17 bodů

5 Překlad

6 Seznámení s vývojovým prostředím
Vytvoření nového projektu Modifikace zdrojového souboru Uložení zdrojového souboru Kompilace zdrojových souborů Spuštění vytvořené aplikace Kompilace a spuštění v jednom kroku Ladění

7 Základní struktura programu v jazyce C
// vložení standardního hlavičkového souboru #include <stdio.h> // vložení vlastního hlavičkového souboru #include "main.h" // vstupní bod aplikace int main(int argc, char *argv[]) {     // příkazy } Komentáře // jednořádkový komentář /* Víceřádkový    komentář  */

8 Proměnné Deklarace typ_proměnné identifikátor_proměnné;
Globální vs. lokální proměnná int i;    // globální proměnná funkce() {     int j;    // lokální proměnná } Počáteční inicializace int i = 5; // deklarace proměnné i a její inicializace na hodnotu 5 // totéž složitěji int i;    // deklarace proměnné i i = 5;   // nastavení proměnné i na hodnotu 5

9 Datové typy v jazyce C Celočíselné char (8 bitů) short (16 bitů)
int (32 bitů) long (64 bitů) Reálné float (32 bitů) double (64 bitů) Výčtový enum Ukazatel pointer (32 bitů) Velikost některých datových typů je platformě závislá.

10 unsigned vs. signed unsigned neznaménkový datový typ
unsigned char (0..255) unsigned short ( ) unsigned int ( ) unsigned long signed znaménokový datový typ signed char ( ) signed short ( ) signed int ( ) signed long

11 Konstanty Celočíselné desítkové 1, 10, 129 long 12L, -35l
unsigned 33U, 12u oktálové 01, 010, 0127 hexadecimální 0x1, 0x1F, 0x12A Reálné double 1E10, 15e-1, 3.14 , .2 float 1E5F, 123ef long double 15e3L Znakové (velikost int!) 'a', '/', \007, \x1f, \n, \r, \t, \0 klíčové slovo const const int i = 15;

12 Operace Operátor přiřazení = Aritemetické operace +,-, *, /, %
Složené operátory přiřazení +=, -=, +=, /=, %=, >>=, <<=, &=, |=, ^= Operátory inkremenace/dekrementace o jedničku ++, -- Relační operátory >, >=, <, <=, ==, != Logické operátory !, &&, || Bitové operace &, |, ^, ~, <<, >>

13 Priority a postup vyhodnocování výrazů

14 Konverze datových typů
Implicitní Prováděna automaticky. Vždy se konvertuje z "nižšího" typu na "vyšší". Pořadí typů pro konverzi: int -> unsigned int -> long -> unsigned long -> double -> long double double x; int i = 5; x = i; double r; r = i * x; // hodnota proměnné i je konvertována na double Explicitní Prováděna na žádost programátora. double x = 5; int i; i = (int) x;    // jedná se v podstatě o „ořezání“ desetinné části

15 Klíčová slova auto, break, case, char, const, continue, default, do
double, else, enum, extern, float, for, goto, if int, long, register, return, short, signed, sizeof, static struct, switch, typedef, union, unsigned, void, volatile, while Mají předem daný význam => nelze použít jako indentifikátor!

16 Větvení - příkaz if Úplná podmínka if (výraz) {
    // příkazy, které se provedou, když je výraz <> 0 } else     // příkazy, které se provedou, když je výraz == 0 Neúplná podmínka

17 Výběr z více alternativ - příkaz switch
Syntaxe switch (výraz) {     case x :         // příkazy, které se provedou, když výraz == x     break;     case y :     case l:     case k:         // příkazy, které se provedou, když výraz == l || výraz == k     ...     default : /* příkazy, které se provedeou, pokud neodpovídá ani jedna z předchozích variat */ }

18 Cyklus - příkaz for Syntaxe for ( inicializace; podmínka; přízak(y)) {
    // tělo cyklu } Příklad int i; for (i = 0; i < 10; i++)     printf("Ahoj svete %d\n", i);

19 Cyklus - příkaz do Syntaxe do { // tělo cyklu } while (podmínka);
Příkazy v těle cyklu jsou prováděny, když je splněna podmínka na konci (za tělem). => Tělo cyklu je provedeno minimálně 1x!

20 Cyklus - příkaz while Syntaxe while (podmínka) { // tělo cyklu }
Příkazy v těle cyklu jsou prováděny, když je splněna podmínka na začátku. => Tělo cyklu se nemusí provést vůbec!

21 Příkaz continue Příklad int i = 0; while (i < 5) { i++;
    if ((i % 2) == 0)         printf("%d je sude", i);     else         continue;    // skok na začátek cyklu     printf("\n"); }

22 Příkaz break Příklad int i = 0; while (i < 5) { i++;
    if ((i % 2) == 0)         printf("%d je sude", i);     else         break;    // skok z cyklu ven     printf("\n"); }

23 Příkaz goto for (i = 0; i < 10; i++) {
    for (j = 0; j < 10; j++) {         if (d[j] == 0)             goto chyba;         else             r[i]+= 1 / d[j];     } } goto bez_chyby; chyba: printf("Deleni nulou\n"); Pokud možno nepoužívat! Problém je vždy možné vyřešit bez tohoto příkazu!!!

24 Bloky { // začátek bloku // tělo bloku = příkazy, definice proměnných
}    // konec bloku Nutnost použití bloků u if, do, while, pokud tělo bloku obsahuje více než jeden příkaz. if (i == 1)     printf("jen jeden příkaz") if (i == 10) {     printf("první příkaz");     printf("druhý příkaz"); }

25 Viditelnost proměnných
int a = 4;        // globální proměnná void main() {    printf("a = %d\n", a); /* lokální proměnná, překrývá dříve deklarovanou      proměnnou se stejným názvem */    int a = 5;    printf("a = %d\n", a);    {       int j; // proměnná je "vidět" jen v rámci bloku    } }

26 Deklarace proměnných - chyba
int a = 4;        // globální proměnná void main() {    printf("a = %d\n", a); /* lokální proměnná, překrývá proměnné se stejným    názvem deklarované v nadřazených úrovních */    int a = 5;    printf("a = %d\n", a); // opětovná deklarace v rámci stejného bloku!!!    int a = 6; }

27 Paměťové třídy auto implicitní třída pro lokální proměnné extern
pro sdílení proměnných mezi více soubory static lokální proměnná, která si uchovává hodnotu mezi jednotlivými voláními funkce globální proměnná, která je viditelná pouze v modulu, kde je definována register doporučení překladači, aby uložil proměnnou do registru počítače

28 Typové modifikátory const
hodnota proměnné se po inicializaci již nemění volatile upozornění překladače, že proměnná může být modifikována asynchronně

29 Funkce návratový_typ identifikátor_funkce(parametry_funkce) {
    // tělo funkce     return výraz;    // výraz je typu návratový_typ } Příkaz return ukončí provádění funkce. Nemusí být až na jejím konci. Když je návratový typ funkce void, příkaz return neobsahuje žádný výraz.

30 Volání funkcí Volání funkce hodnotou // funkce se volá secti (5, 3);
int secti(int a, int b) {    return (a+b); } Volání funkce odkazem // funkce se vola prohod(&x, &y); void prohod(int *a, int *b)    int pom = *b;    *b = *a;    *a = pom;

31 Prototyp funkce Příklad int soucet(int a, int b); // prototyp funkce
int main() {    int a, b;    scanf("%d%d", &a, &b);    printf("%d + %d = %d\n", a, b, soucet(a, b)); } int soucet(int a, int b)    return a + b;

32 Rekurze Funkce pro výpočet faktoriálu int fakt(int n) {
int fakt(int n) {    if (n <= 0) {       return 1;    }    else    {       return n * fakt(n - 1); }

33 Fibonacciho posloupnost
Fibonnaciho posloupnost posloupnost, kde první člen f(0) = 0 a druhý člen f(1) = 1 a každý další člen je součet dvou předchozích f(n) = f(n-1) + f(n-2)

34 Fibonacciho posloupnost - rekurze
int fibonacci(int n) {    if (n < 2)    {       if (n < 1)          return 0;       else          return 1;    } else       return (fibonacci(n-1) + fibonacci(n-2)); }

35 Fibonacciho posloupnost - cyklus
int fibonacciC(int n) {    int p[MaxN];    p[0] = 0;    p[1] = 1;    int i;    for (i = 2; i <= n; i++)    {       p[i] = p[i-1] + p[i-2];    }    return p[n]; }

36 Terminálový vstup/výstup
Hlavičkový soubor stdio.h    #include <stdio.h> Funkce pro vstup    getchar()   // čte první znak, čtení se ukončí stiskem Enter    scanf()     // formátovaný vstup Funkce pro výstup putchar()   // zapíše znak    printf()    // formátovaný výstup

37 Formátovaný vstup Funkce scanf() Příklad int i; scanf("%d", &i);
Příklad    int i;    scanf("%d", &i); %d určuje formát vstupu (v tomto případě celé číslo). &i adresa proměnné, do které se má vstup uložit Pozor!!! Nazapomenout na & před názvem proměnné!!!

38 Formátovaný výstup Funkce printf() Příklad int i = 5;
Příklad    int i = 5;    printf("i = %d", i); i = text, který se vypíše %d určuje formát výpisu (v tomto případě dekadický celočíselný) i proměnná, která se vytiskne na terminál tam, kde je %d

39 Formátové specifikace
%c     znak (je lepší použít funkci getchar() nebo putchar()) %d     celé číslo typu signed int %ld    celé číslo typu signed long %u     celé číslo typu unsigned int %lu    celé číslo typu unsigned long %f      reálné číslo typu float %lf     reálné číslo typu double %Lf    reálné číslo typu long double (L musí být velké) %x     číslo v hexadecimálním tvaru s malými písmeny - 5b8f %X    číslo v hexadecimálním tvaru s velkými písmeny - 5B8F %o     číslo v osmičkovém tvaru %s     řetězec

40 Escape sekvence \0     Nula, ukončení řetězce (má být na konci každého řetězce) \a     Pípnutí \b     Návrat o jeden znak zpět \f      Nová stránka nebo obrazovka \n     Přesun na začátek nového řádku \r      Přesun na začátek aktuálního řádku \t      Přesun na následující tabelační pozici \v     Stanovený přesun dolů \\      Obrácené lomítko \'      Apostrof \"     Uvozovky \?    Otazník

41 Operátor čárka Nejprve je vyhodnocen výraz vlevo od čárky, následně je vyhodnecen výraz vpravo od čárky. Syntaxe výraz: výraz1, výraz2 Příklad 1 (nejčastější použití) for (i = 0, j = 0; i < 5; i++, j++) {    //... } Příklad 2 int a, b = 1, c = 2; a = (b++, b + c);

42 Ternární operátor Syntaxe výraz_podmínka ? výraz1 : výraz2 Příklad
Příklad x = (a < b) ? a : b; Totéž pomocí if if (a < b)    x = a; else    x = b;

43 Pole – statická – jednorozměrná
Syntaxe      datovy_typ identifikator_pole[pocet_prvku_pole];   datovy_typ identifikator_pole[pocet_prvku_pole] = {p0, p1, ...}; Příklad 1 (práce s polem) int pole[3]; int i; for (i = 0; i < 3; i++) { printf(“zadej %d. cislo: “, i); scanf(“%d”, &pole[i]); } printf(“%d. cislo: %d\n”, i, pole[i]); Příklad 2 (pole jako argument funkce) int minimum(int pole[], int pocet) { // vypocet minima...

44 Pole – statická – vícerozměrná
Syntaxe      datovy_typ identifikator[pocet_prvku1][pocet_prvku2]      datovy_typ identifikator[pocet_prvku1][pocet_prvku2] = {{p00},{},...} Příklad 1 (inicializace) int matice[3][2] = {{1,2}, {3,4}, {5,6}}; Příklad 2 (přístup k prvkům pole) int matice[3][2]; matice[0][0] = 1; matice[0][1] = 2; matice[1][0] = 3; matice[1][1] = 4; matice[2][0] = 5; matice[2][1] = 6;

45 Řetězce Jednorozměrné pole typu char[] ukončené znakem '\0'! Deklarace
Deklarace char retezec[10]; Inicializace char retezec[10] = "ahoj"; char retezec2[] = "ahoj"; Příklad 1 char retezec[10] = "ahoj", retezec2; printf("%d", retezec[0]); printf("%d", retezec[1]); printf("%d", retezec[2]); printf("%d", retezec[3]); printf("%d", retezec[4]); printf("%s", retezec); scanf("%s", retezec2); printf("%s", retezec2);

46 Standardní funkce pro práci s řetězci
Hlavičkový soubror <string.h> Délka řetězce     strlen(); Kopírování řetězce     strcpy(); Spojení řetězců     strcat(); Nalezení znaku v řetězci     strchr(); Porovnání dvou řetězců     strcmp(); Nalezení pořetězce v řetězci     strstr();

47 Ukazatele (Pointery) Příklad int i = 5; int *p_i = &i;
printf("adr. &i=%p, &p_i=%p, p_i=%p\n", &i,&p_i,p_i); printf("hodnoty i=%d, p_i=%d\n", i, *p_i); i++; (*p_i)++;  *p_i = 11; 

48 Pointerová aritmetika
Příklad int a[5] = {1,2,3,4,5}; int *p = a;  // totez co int *p = &a a int *p = &a[0] printf("adr. &a=%p, a=%p, &p=%p, p=%p\n", &a, a, &p, p); printf("hodnoty a[0]=%d, *p=%d\n", a[0], *p); printf("hodnoty a[1]=%d, *(p+1)=%d\n", a[1], *(p+1)); printf("hodnoty a[4]=%d, *(p+4)=%d\n", a[4], *(p+4)); p = p + 3; printf("adr. &a[3]=%p, &p=%p, p=%p\n", &a[3], &p, p); printf("hodnoty *p=%d\n", *p); p--; printf("hodnoty a[2]=%d, *p=%d\n", a[2], *p); *p = 50; *(p+1) = 44; printf("hodnoty a[3]=%d, *(p+1)=%d\n", a[3], *(p+1));

49 Pointery jako argumenty funkcí
Příklad na prohození dvou čísel int prohod(int *a, int *b) {    int pom = *a;    *a = *b;    *b = *a; }

50 Ukazatel na funkce Příklad int soucet(int a, int b) { return a + b; }
int rozdil(int a, int b) {    return a - b; void main() {    int (*p_f)(int a, int b);    p_f = soucet;    printf("%d\n", p_f(1, 2));    p_f = rozdil;

51 Dynamická paměť Alokace paměti void *malloc(size_t size);
Uvolnění paměti void free(void *pointer); Alokace paměti s nastavením hodnot na 0 void *calloc(size_t nelements, size_t bytes); Realokace paměti void *realloc(void *pointer, size_t size); Určení velikosti typu – operátor sizeof()

52 Dynamická paměť Příklad 1 int *p_i; // alokace pameti
p_i = (int*)malloc(100*sizeof(int)); if (p_i == NULL) { // alokace se nezdarila } else { // prace s polem p_i p_i[0] = 5; // uvolneni pameti free(p_i); }

53 Dynamická paměť Příklad 2 int *p_i, *p_i2; // alokace pameti
p_i = (int*)malloc(100*sizeof(int)); if (p_i == NULL) { // alokace se nezdarila } else { // realokace pameti p_i2 = (int*)realloc(p_i, 10); if (p_i2 == NULL) { // realokace se nezdarila // prace s polem p_i p_i[0] = 5; // uvolneni pameti free(p_i); }

54 Vícerozměrná dynamická pole
Realizace pomocí dynamického pole pointerů ukazujících na dynamické pole. Příklad // pro jednoduchost se netestuje uspesnost alokace #define radky 10 #define sloupce 10 int **pole, i; // alokace pameti pro pointery (ukazatele na radky) pole = (int**)malloc(radky*sizeof(int*)); // alokace pameti pro jednotlive radky for (i = 0; i < radky; i++) pole[i] = (int*)malloc(sloupce*sizeof(int)); // prace s polem scanf(”%d”, &pole[0][0]); printf(”%d”, pole[0][0]); // uvolneni pameti – nejprve radky, pak ukazatele free(pole[i]); free(pole);

55 Argumenty programu Vstupní bod aplikace:
int main(int argc, char *argv[]) argc – počet argumentů (název programu je taky argument) arg[] – ukazatel na pole argumentů arg[0] – název programu arg[1] – 1. argument programu Příklad int main(int argc, char *argv[]) { int i; printf(“Pocet argumentu: %d”, argc); for (i = 0; i < argc; i++) printf(“Argument %d: %s”, i, argv[i]); return 0; }

56 Definice typů - typedef
Pro definici/pojmenování nových typů – pointery typedef int *P_INT; P_INT p_int; Pro definici/pojmenování nových typů – struktury (viz dále) Přiklad (pointer na pointer) typedef P_INT *P_P_INT; P_P_INT p_p_i; //totez znamym zpusobem int **p_p_int;

57 Struktury Definice struktury a proměnných jirka, alois struct {
char jmeno[10]; char prijmeni[20]; int vek; } jirka, alois; Definice pojmenované struktury a proměnných jirka, alois struct osoba {

58 Struktury Definice struktury a následná deklarace proměnných jirka, alois struct osoba { char jmeno[10]; char prijmeni[20]; int vek; }; struct osoba jirka, alois; Definice nového typu a proměnných jirka, alois tohoto typu typedef struct { } OSOBA; OSOBA jirka, alois;

59 Struktury – příklad Příklad typedef struct { char jmeno[10];
char prijmeni[20]; int vek; } OSOBA; OSOBA osoby[10]; void main() { printf(“Zadejete jmeno 1. osoby: ”); scanf(“%s”, &osoby[0].jmeno); printf(“Zadejete prijmeni 1. osoby: ”); scanf(“%s”, &osoby[0].prijmeni); printf(“Zadejete vek 1. osoby: ”); scanf(“%d”, &osoby[0].vek); printf(“Osoba 1: %s %s (%d)”, osoby[0].jmeno, osoby[0].prijmeni, osoby[0].vek); }

60 Výčtový datový typ – enum
Příklad typedef enum { MODRA, BILA, ZLUTA, CERVENA, HNEDA } BARVY; BARVY barva = MODRA; char *nazvy[] = {”Modra”, ”Bila”, ”Zluta”, ”Cervena”, ”Hneda” }; printf(”Vybrana barva %s\n”, nazvy[barva]); Přiřazení hodnot konstantám MODRA = 5, BILA = 2, ZLUTA = 7,

61 Union Definice typedef union { int i; float f; char c; } PRVEK;
PRVEK prvky[10]; Použití Vždy se může použít jen jeden z prvků unionu, protože všechny sdílejí stejnou paměť Union nenese informaci o typu prvku v něm uloženém Přístup je stejný jako ke struktuře (prvky[0].i = 5) K zamyšlení Jak poznat typ prvku v unionu?

62 Bitová pole Struktura o velikost int
Můžeme definovat počet bitů, které jednotlivé prvky struktury zabírají Příklad 1 typedef struct { unsigned hodina : 5; // 0 az 23 => min. 5 bitu unsigned minuta : 6; // 0 az 59 => min. 6 bitu unsigned sekunda : 6; // 0 az 59 => min. 6 bitu } CAS; CAS mujCas; mujCas.hodina = 10; mujCas.minuta = 58; mujCas.sekunda = 50; Příklad 2 Funkce, která vrátí rozdíl dvou časů.

63 Práce se soubory Postup práce se soubory Dva typy souborů
Otevření souboru Práce se souborem Uzavření souboru Ošetření chyb, které mohou nastat Dva typy souborů Textové soubory Binární soubory

64 Práce se soubory – otevření/uzavření
Otevření souboru pomocí fopen(); Režimy otevření: r w a r+ w+ a+ Uzavření soboru pomocí fclose();

65 Práce se soubory – čtení/zápis
Textové soubory fgetc() fputc() fscanf() fprintf() fgets() fputs() Binární soubory read() write()

66 Práce se soubory – testování konce řádku/souboru
Konec řádku Konec souboru

67 Práce se soubory – pohyb v rámci souboru
Vrácení posledního přečteného znaku zpět do bufferu Funkce ungetch(); Funguje většinou jen na poslední přečtený znak Pohyb v rámci souboru Funkce fseek();

68 Standardní hlavičkové soubory
<assert.h> – makra pro ladění <ctype.h> – práce s znaky <math.h> – matematické funkce (přesnost double) <locale.h> – práce v národním prostředí <setjmp.h> – umožnění běžně nedovolených skoků <signal.h> – zpracování signálů <stdarg.h> – podpora proměnného počtu argumentů <stdio.h> – funkce pro vstup a výstup <stdlib.h> – běžné funkce <string.h> – práce s řetězci <time.h> – práce s datem a časem <errno.h> – systémové chyby <limits.h> – charakteristiky celých čísel <float.h> – charakteristiky reálných čísel <stddef.h> – standardní definice

69 Funkce pro práci se soubory
(viz dříve) + hlavičkový soubor <stdio.h> Přejmenování souboru int rename(const char *old, const char *new); Ostranění souboru int remove(const char *fileName);

70 Práce se znaky – <ctype.h>
isalnum() – je číslice nebo písmeno? isalpha() – je písmeno? isdigit() – je číslice? isxdigit() – je hexadecimální číslice? iscntrl() – je řídicí znak? islower() – je malé písmeno? isupper() – je velké písmeno? isspace() – je mezera? tolower() – převod na malé písmeno toupper() – převod na velké písmeno

71 Matematické funkce – <math.h>
Goniometrické funkce: sin(x), cos(x), tan(x), asin(x), acos(x), atan(x), atan(x, y), sinh(x), cosh(x), tanh(x) Exponenciální funkce: exp(x) = ex Přirozený logaritmus: log(x) Dekadický logaritmus: log10(x) Umocnění: pow(x, y) = xy Druhá odmocnina: sqrt(x) Zaokrouhlení nahoru: ceil(x) Zaokrouhlení dolů: floor(x) Absolutní hodnota: fabs(x) Reálný zbytek po dělení x/y: fmod(x,y)

72 Funkce pro vstup a výstup <stdio.h>
Práce se soubory fopen(), fclose(), remove(), rename(), fprintf(), fscanf(), fgetc(), fgets(), fputc(), fputs(), ungetc(), fread(), fwrite(), fseek(), ftell(), rewind(), fgetpos(), fsetpos(), feof() Práce se standardním vstupem a výstupem printf(), scanf(), getc(), gets(), putc(), puts(), getchar(), putchar(), Práce s řetězci sprintf(), sscanf(),

73 Standardní knihovna <stdlib.h> 1/2
Konverzní funkce atof() – konverze řetězce na double atoi() – konverze řetězce na int atol() – konverze řetězce na long int strtod() – konverze řetězce na double strtol() – konverze řetězce na long int strtoul() – konverze řetězce na unsigned long int Generování náhodných čísel rand() – generování náhodného čísla srand() – inicializace generátoru náhodných čísel Práce s dynamicky alokovanou pamětí calloc() – alokace dynamické paměti s inicializací malloc() – alokace dynamické paměti realloc() – realokace dynamické paměti free() – uvolnění dynamicky alokované paměti

74 Standardní knihovna <stdlib.h> 2/2
Ukončení programu abort() – nestandardní ukončení programu exit() – standardní ukonční programu atexit() – registrace ukončovací funkce Matematické funkce abs() – absolutní hodnota typu int labs() – absolutní hodnota typu long int div(x, y) – x/y a x%y současně pro typ int ldiv(x, y) – x/y a x%y současně pro typ long int Systémové funkce system() – volání systémového příkazu getenv() – poskytnutí informace o systémové proměnné Třídění bsearch() – binární vyhledávání qsort() – řazení algoritmem quick-sort

75 Funkce pro práci s časem <time.h>
Počet tiků procesoru: clock() Počet sekund od 1. ledna 1970: time() Rozdíl dvou časů: difftime() Práce s položkami času: mktime() Konverze času do řetězce: asctime() Konverze počtu sekund do řetězce: ctime() Práce s GMT: gmtime() Výpočet složek času z počtu sekund: localtime() Formátová konverze složek času do řetězce: strftime()

76 Dynamické datové struktury – seznam
text