Algoritmizace a programování Cvičení Jan Kordas jan.kordas@vsb.cz D400   2008

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.

Materiály Soubor materiálů k přemětu http://fei1.vsb.cz/stud_mat/K455/BAKALARI/2.rocnik/Algoritmizace/   Webové stránky ke cvičení http://homel.vsb.cz/~kor206/teaching/ap_cv.html Cvičení z minulých let http://skola.gamisk.net/ http://skolavsb.wz.cz/cecko/ 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

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

Překlad

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í

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ář  */

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

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á.

unsigned vs. signed unsigned neznaménkový datový typ unsigned char (0..255) unsigned short (0..65535) unsigned int (4294967296) unsigned long   signed znaménokový datový typ signed char (-128..127) signed short (-32768..32767) signed int (-65536..65535) signed long

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;

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 &, |, ^, ~, <<, >>

Priority a postup vyhodnocování výrazů http://msdn.microsoft.com/en-us/library/2bxt6kc4(VS.71).aspx

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

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!

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

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 */ }

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);

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!

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!

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"); }

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"); }

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!!!

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"); }

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    } }

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; }

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

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ě

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.

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;

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;

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); }

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)

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)); }

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]; }

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

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é!!!

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

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

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

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);

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;

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...

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;

Ř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);

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();

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; 

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));

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

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;

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()

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); }

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); }

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);

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; }

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;

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 {

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;

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); }

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,

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?

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ů.

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

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();

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

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

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();

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

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);

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

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)

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(),

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

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

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()

Dynamické datové struktury – seznam text