252

´ Uvod ISO C libc C99 Debug C++ Link Opt .

IJC — Jazyk C Petr Peringer peringer AT fit.vutbr.cz Vysoke´ uˇcen´ı technicke´ v Brneˇ Fakulta informaˇcn´ıch technologi´ı, ˇ Boˇzetechova 2, 61266 Brno

(Verze 2016-02-08) (Pˇreloˇzeno: 8. unora 2016) ´

IJC — Jazyk C

1/252


Pravidla Literatura

´ Uvod ˇ IJC na FIT. Tyto slajdy jsou urˇceny pro studenty pˇredmetu Obsahuj´ı popis jazyka ISO C vhodný pro studenty, kteˇr´ı jiˇz ´ nekter´ ˇ ´ zvladli y z vyˇssˇ ´ıch programovac´ıch jazyku˚ (zaklady C, ˇ s´ı Pascal, ...). Obsah slajdu˚ je velmi struˇcný, podrobnejˇ ´ ı výkladu. Pˇredpoklad ´ a´ se teˇ ´z informace jsou souˇcast´ ´ studentu˚ s literaturou. samostatna´ prace ´ ´ Programy jsou sazeny nasleduj´ ıc´ım zpusobem: ˚ ---------|---------|---------|---------|---------| text programu a pozn´ amky (max 50 znak˚ u) ˇ ı. ˇ ´ Nekde budou pouˇzity rameˇ cky pro zvýraznen´

IJC — Jazyk C

2/252


Pravidla Literatura

Pravidla

IJC = ´ sky pˇrednaˇ ukoly ´ konzultace hodnocen´ı celkem 100 bodu: ˚ 30b 2 ukoly ´ 70b zkouˇska

IJC — Jazyk C

3/252


Pravidla Literatura

Zdroje informac´ı

Dobra´ literatura WWW odkazy ´ ı stranka: ´ Oficialn´ http://www.fit.vutbr.cz/study/courses/IJC/ ´ ı informace pro studenty: Aktualn´ http://www.fit.vutbr.cz/study/courses/IJC/public/ man 3 ´ ˇ ´ prostˇred´ı Napov eda v integrovanem ...

IJC — Jazyk C

4/252


Pravidla Literatura

Literatura British Standards Institute: The C Standard: Incorporating Technical Corrigendum 1, Willey, 2003 (c99) ´ ı, Kopp, 2008 Herout, P.: Uˇcebnice jazyka C, 5. vydan´ ISO: Programming languages – C, WG14 N1570 Committee Draft, April 12, 2011 Kerninghan, B.; Ritchie, D.: The C Programming Language, 2nd edition, Addison-Wesley, 1988 Kerninghan, B.; Ritchie, D.: Programovac´ı jazyk C, Computer Press, 2006 Kernighan B., Pike R.: The Practice of Programming, Addison-Wesley, 1999

IJC — Jazyk C

5/252


´ ´ Uvod Ukazatele Operatory Pˇr´ıkazy Moduly Makra

Historie jazyka C ALGOL 60 CPL BCPL B C ANSI C ISO C90 ISO C90 + TC ISO C99 ISO C99 + TC ISO C11

(1960) (1963) (1967) (1970) (1972) (1989) (1990) (1994) (1999) (2004) (2011)

Bell Laboratories K&R norma pro USA mezin´ arodn´ ı norma doplˇ nky a opravy mezin´ arodn´ ı norma doplˇ nky a opravy = platn´ y standard

Kerninghan, Ritchie: The C Programming Language (Addison-Wesley 1978). ´ ı norma: ISO/IEC 9899:2011 (C11) Aktualn´ Pˇrekladaˇce a vývojova´ prostˇred´ı pro jazyk C – viz WWW IJC — Jazyk C

6/252



Novinky v C11 ˇ ´ normy jsou nepovinne´ (”optional”) nekter e´ cˇ asti ´ podpora vlaken (”threads”) ´ an´ ´ ı (”alignment”) moˇznost specifikovat zarovnav ˇ UNICODE znaky a rˇetezce (bylo v revizi 2004) typoveˇ genericke´ výrazy ”static assert” anonymn´ı struktury a unie ´ funkce bez navratu likvidace funkce gets výluˇcný pˇr´ıstup k souborum ˚ ˇ ı charakteristik pro float/double/... doplnen´ volitelna´ podpora pro kontrolu mez´ı a analýzu IJC — Jazyk C

7/252



Charakteristika jazyka C Obecneˇ vyuˇzitelný programovac´ı jazyk tradiˇcneˇ pouˇz´ıvaný ´ ´ ı. pro systemov e´ programovan´ ˇ C je jazyk ’niˇzsˇ ´ı urovn e’ ´ ´ Otevˇrený jazyk; male´ jadro je snadno rozˇsiˇritelne´ (knihovny) Dobˇre napsane´ programy v C jsou efektivn´ı Existuje velke´ mnoˇzstv´ı programu˚ napsaných v C ´ ı jistých pravidel Programy jsou pˇrenositelne´ pˇri dodrˇzovan´ Existuj´ı pˇrekladaˇce na prakticky vˇsechny platformy ´ ı d´ıky operaˇcn´ımu systemu ´ Popularn´ UNIX. Je standardizovaný (ISO/ANSI)

IJC — Jazyk C

8/252



Nevýhody jazyka C

´ ˇ ´ zcela Nedisciplinovanemu uˇzivateli umoˇznuje psat nesrozumitelne´ programy (i["abcdef"], IOCCC) Je nutne´ dodrˇzovat jiste´ konvence nekontrolovane´ pˇrekladaˇcem (ale existuj´ı prostˇredky na dodateˇcne´ kontroly — napˇr´ıklad program lint): parametry funkce printf meze pol´ı ´ ı programu konzistence pˇri sestavovan´ ...

´ ı sprava ´ pameti. ˇ (Ne vˇzdy jde o nevýhodu. Existuje Manualn´ moˇznost pouˇz´ıt ”garbage collector”– viz napˇr. libgc) ...

IJC — Jazyk C

9/252



Doporuˇcený styl psan´ı programu˚ if ( a > b ) { text odsazen´ y o 2-8 znak˚ u }

/* varianta A */

if ( a > b ) { text odsazen´ y o 2-8 znak˚ u }

/* varianta B */

´ an´ ´ ı textu programu je duleˇ Zarovnav ˚ zite´ pro jeho dobrou ´ ı nevyˇzaduj´ı ani nekontroluj´ı. cˇ itelnost. Pˇrekladaˇce zarovnan´ ´ Poznamky: ´ an´ ´ ı zdrojových textu˚ (GNU indent) Automaticke´ formatov ´ ı dokumentace ze zdrojových textu˚ Automaticke´ generovan´ programu˚ (napˇr. doxygen). IJC — Jazyk C

10/252



Prvn´ı program Soubor ahoj.c #include <stdio.h>

/* vloˇ z´ ı rozhran´ ı */

int main(void) { printf("Ahoj!\n"); return 0; } ´ ı Zpusob ˚ zpracovan´ cc ahoj.c ./a.out

# pro Linux, UNIX, GNU C

´ Poznamka: Struktura programu v jazyku C IJC — Jazyk C

11/252



´ Zakladn´ ı datove´ typy

void char short int long long long float double

pr´ azdn´ a mnoˇ zina hodnot znak kr´ atk´ e cel´ e ˇ c´ ıslo cel´ e ˇ c´ ıslo (+-podle registru procesoru) dlouh´ e cel´ e ˇ c´ ıslo (min 32 bit˚ u) velmi dlouh´ e cel´ e ˇ c´ ıslo (min 64 bit˚ u) re´ aln´ e ˇ c´ ıslo re´ aln´ e ˇ c´ ıslo s dvojn´ asobnou pˇ resnost´ ı

Implicitn´ı typove´ konverze int ⇐⇒ float char ⇐⇒ int

IJC — Jazyk C

12/252



ˇ ezce ˇ Ret ˇ ezcov ˇ ´ (C11) Ret e´ literaly "text ˇ retˇ ezce m˚ uˇ ze obsahovat speci´ aln´ ı znaky (char[])" u8"text UTF-8 (char[])" u"text UTF-16 (char16_t[])" U"text UTF-32 (char32_t[])" L"text (wchar_t[])" \\ \" \t ...

= znak \ = znak " = tabel´ ator (posun na n´ asleduj´ ıc´ ı sloupec N*8)

´ Poznamky: ´ Pozor na jmena souboru˚ v MS-DOS stylu ("c:\text.txt") Pozor na dalˇs´ı omezen´ı – napˇr. *printf() %% IJC — Jazyk C

13/252



Funkce printf printf("form´ atovac´ ı ˇ retˇ ezec" [, parametry]); ´ ı jazyka Knihovn´ı funkce, nen´ı souˇcast´ ´ ˇ Formatovac´ ı ˇretezec popisuje zpusob tisku parametru, ˚ ˚ ´ ı význam – oznaˇcuje zaˇcatek ´ ´ znak % ma´ specialn´ formatu ´ ´ Zakladn´ ı formaty %f %d %o %x %c %s %% IJC — Jazyk C

ˇ´ c ıslo v plovouc´ ı ˇ c´ arce des´ ıtkov´ e cel´ e ˇ c´ ıslo oktalov´ e cel´ e ˇ c´ ıslo sestn´ ˇ actkov´ e cel´ e ˇ c´ ıslo znak retˇ ˇ ezec znak˚ u znak % 14/252



Pˇr´ıkaz for

for(poˇ c_nastaven´ ı; test; nastav_dalˇ s´ ı_krok) for(;;) { .... } /* nekoneˇ cn´ y cyklus */

Pˇr´ıklad int main(void) { int i; for(i=1; i<=10; i++) printf(" %f \n", 1.0/i); return 0; }

IJC — Jazyk C

15/252



Symbolicke´ konstanty

#define

JMENO

hodnota

#define

ZACATEK 1

Pouˇzit´ı const nebo enum const int ZACATEK = 1; enum { ZACATEK = 1 }; nen´ı zcela ekvivalentn´ı, ale obecneˇ lepˇs´ı.

IJC — Jazyk C

16/252



Standardn´ı vstup ˇ ıtan´ ´ ı znaku˚ Pˇr´ıklad: poc´ int main(void) { long nc = 0; /* zaruˇ cen´ y rozsah do 2e9 */ while(getchar()!=EOF) /* ˇ cten´ ı znaku */ nc++; printf("%ld znak˚ u \n", nc); } /* ^------------ long */ Druha´ verze int main(void) { for( long nc = 0; getchar()!=EOF; nc++ ) ; // pr´ azdn´ y pˇ r´ ıkaz - vˇ se je v z´ ahlav´ ı printf("%ld znak˚ u \n", nc); return 0; } IJC — Jazyk C

17/252



´ ı souboru Pˇr´ıklad: kop´ırovan´

Standardn´ı vstup → standardn´ı výstup #include <stdio.h> int main(void) { int c; while ( (c = getchar()) != EOF ) putchar(c); return 0; }

IJC — Jazyk C

// priorita =

18/252



´ ı slov Pˇr´ıklad: poˇc´ıtan´ int main(void) { int c; long nl=0, nw=0, nc=0; // poˇ cet ˇ r´ adk˚ u, slov a znak˚ u bool inword = false; // stav automatu while( (c = getchar()) != EOF ) { nc++; if( c == ’\n’ ) nl++; // nov´ y ˇ r´ adek if( c == ’ ’ || c == ’\n’ || c == ’\t’ ) inword = false; // oddˇ elovaˇ c else if( !inword ) { inword = true; // zaˇ c´ ın´ a slovo nw++; } } printf("%ld %ld %ld\n", nl, nw, nc); return 0; } IJC — Jazyk C

19/252



Pˇr´ıklad: histogram poˇctu cˇ ´ıslic int main(void) { int c; // naˇ cten´ y znak int ndigit[10] = { 0, }; while( (c=getchar()) != EOF ) if(isdigit(c)) // je ˇ cı ´slice? ndigit[c-’0’]++; // znak --> ˇ c´ ıslo printf("digit: number\n"); for(int i=0; i<10; i++) printf("’%c’: %d\n", i+’0’, ndigit[i]); printf("\n"); return 0; }

IJC — Jazyk C

20/252



Definice funkce ISO C int power(int x, int n) { /* umocˇ nov´ an´ ı */ int p; for( p=1; n>0; n-- ) p = p * x; return p; /* n´ avrat s hodnotou p */ } ´ ı funkce Volan´ printf("%d %d %d\n", i, power(2,i), power(-3,i)); ´ an´ ´ ı parametru˚ hodnotou (kromeˇ pole) ´ Poznamka: Pˇredav ´ Poznamka: Prototyp funkce IJC — Jazyk C

21/252



K&R definice funkce

´ nepouˇz´ıvat) Podle K&R (velmi zastarale, power(x, n) /* K&R: implicitn´ ı typ int */ int x, n; /* K&R: deklarace parametr˚ u */ { int i, p; for( i=p=1; i<=n; i++ ) p = p * x; return p; } ´ Poznamka: K&R nezna´ pojem prototyp funkce

IJC — Jazyk C

22/252



´ Pˇr´ıklad: nalezen´ı nejdelˇs´ıho ˇradku v textu ... #define MAXLINE 1000 /* implementaˇ cn´ ı limit */ int getline(char s[], int lim) { int c, i; for(i=0; i
23/252



´ ı Pˇr´ıklad: ... pokraˇcovan´ int main(void) { char line[MAXLINE]; /* naˇ cten´ y ˇ r´ adek */ char save[MAXLINE]; /* nejdelˇ s´ ı ˇ r´ adek */ int max = 0; int len; while( (len=getline(line,MAXLINE)) > 0 ) if( len > max ) { /* je delˇ s´ ı? */ max = len; copy(save, line); /* pole pˇ red´ a odkazem */ } if( max > 0 ) printf("%s", save); return 0; } IJC — Jazyk C

24/252



Jazyk C – systematicka´ definice ´ Zakladn´ ı mnoˇzina znaku˚ (1 byte) p´ısmena: a-zA-Z cˇ ´ıslice: 0-9 graficke´ znaky: ! " # %

& ’ ( )

* . < [ ^ | + / = \ _ } , : > ] { ~ ; ? ´ mezera, nový rˇadek, BS, HT, VT, FF ´ ˇ ´ ´ V identifikatorech, znakových/ˇretezcov´ ych literalech, jmenech ´ ach ´ mohou být i jine´ znaky. hlaviˇckových souboru˚ a poznamk

IJC — Jazyk C

25/252



´ Poznamky (comments)

/* text C pozn´ amky */ // text C99+ pozn´ amky do konce ˇ r´ adku // pozn´ amka s trigraph ??/ pokraˇ cuje i na dalˇ s´ ım ˇ r´ adku ´ ISO C nedovoluje vnoˇrene´ poznamky. (Pouˇzijte #if 0 ) ´ ´ Poznamka je pˇrepsana na jednu mezeru aˇz po rozvoji maker ´ Poznamka: ˇ ´ Nekter e´ zastarale´ (ne ISO C) implementace nevkladaly mezeru

IJC — Jazyk C

26/252



´ ´ Operatory a separatory

! % %= & &&

&= ( ) * *=

+ ++ += , -

--= -> . /

/= : ; <

<< <<= <= =

== > >= >>

>>= ? [ ]

^ ^= { |

|= || } ~

´ Poznamka: ´ ´ Operator % a zaporn a´ cˇ ´ısla: C89: ”implementation defined”, C99, C11: LIA (Language Independent Arithmetic) ´ ´ Poznamka: pro znamenkov´ y typ zbytek 6= modulo

IJC — Jazyk C

27/252



´ Identifikatory rozliˇsuj´ı se velka´ a mala´ p´ısmena (case sensitive) ´ ı rozliˇsovana´ delka ´ minimaln´ 63(31) znaku˚ ´ ´ u: konvence pro zapis identifikator ˚ ´ identifikatory preprocesoru velkými p´ısmeny #define YES 1 ´ ostatn´ı identifikatory malými p´ısmeny int i; ´ dlouhe´ identifikatory s podtrˇz´ıtkem mezi slovy int muj_dlouhy_identifikator; ´ ı jmena ´ specialn´ zaˇc´ınaj´ı znakem _ __func__

´ stn´ı prostory jmen pro nav ´ eˇ ˇ st´ı (”labels”), oznaˇcen´ı Zvlaˇ ˇ ˇ struktur/uni´ı/výctu˚ (”tags”), cleny struktur/uni´ı a ostatn´ı ´ idetifikatory. IJC — Jazyk C

28/252



Kl´ıcˇ ova´ slova

auto break case char const continue default do double

else enum extern float for goto if inline int

long register restrict return short signed sizeof static struct

switch typedef union unsigned void volatile while

_Alignas _Atomic _Complex _Imaginary _Static_assert _Alignof _Bool _Generic _Noreturn _Thread_local

IJC — Jazyk C

29/252



Jednoduche´ typy a velikost udaj ´ u˚ void bool char short int int long int long long int float double long double float complex double complex

IJC — Jazyk C

ˇ’ nezab´ıra´ pamet pouze hodnoty true/false znak (vˇzdy 1 bajt, celoˇc´ıselný typ) ´ e´ cele´ cˇ ´ıslo (min 16 bitu) kratk ˚ standardn´ı cele´ cˇ ´ıslo cele´ cˇ ´ıslo, min 32 bitu˚ cele´ cˇ ´ıslo, min 64 bitu˚ ´ e´ cˇ ´ıslo (mala´ pˇresnost) realn ´ e´ cˇ ´ıslo, dvojnasobn ´ realn a´ pˇresnost ´ e´ cˇ ´ıslo, extra pˇresnost (napˇr. 10B) realn komplexn´ı cˇ ´ıslo, pˇresnost float komplexn´ı cˇ ´ıslo, pˇresnost double

30/252



Typy a velikost udaj ´ u˚ |char| <= |short| <= |int| <= |long| <= |long long| Pˇr´ıklady sizeof(T) pro ruzn ˚ e´ architektury char short int long long long float double long double void* IJC — Jazyk C

PC/64bit 1 2 4 nebo 8 8 8 4 8 16 8

PC/32bit 1 2 4 4 8 4 8 12 4

PC/16bit 1 2 2 4 (8) 4 8 10 2 nebo 4 31/252



signed a unsigned unsigned char unsigned unsigned long

signed char unsigned int

const a volatile const T Objekt takto oznaˇcený nelze modifikovat pˇriˇrazen´ım. volatile T ´ ı pˇrekladaˇci provad ´ et ˇ optimalizace pˇri Tato specifikace zabran´ ´ steˇ pˇri komunikaci mezi pˇr´ıstupu k objektu. Významne´ zvlaˇ paraleln´ımi procesy. ´ Poznamka: ”const-correctness” IJC — Jazyk C

32/252



´ cela´ cˇ ´ısla Literaly: ˇ ıselne´ literaly ´ Celoc´ des´ıtkove´ ˇ c´ ıslice1-9 ˇ c´ ıslice0-9 osmiˇckove´ 0 ˇ c´ ıslice0-7 ´ sˇ estnactkov e´ 0x ˇ c´ ıslice0-9, a-f, A-F pˇr´ıpona bez pˇr´ıpony l nebo L ll nebo LL u nebo U

typ int long long long +specifikace unsigned

Pˇr´ıklady 0L 077 IJC — Jazyk C

2999888777UL 0x3F

1234567890123456789LL 0xFFFFU 33/252



´ v plovouc´ı ˇradov ´ ´ Literaly e´ cˇ arce pˇr´ıpona bez pˇr´ıpony l nebo L f nebo F

typ double long double float

Pˇr´ıklady: 0.

.0

1.0e-3L

3.14159F

3e1

-2e+9

´ Poznamky: ´ decimal – des´ıtkový zaklad (finanˇcn´ı aplikace) ´ ´ 0xfeeP10F sˇ estnactkov´ y format:

IJC — Jazyk C

34/252



´ Znakove´ literaly ´ je typu int ’’ znakový literal, ´ ı znaky (”escape-sequence”) Specialn´ \’ \a \b \f \n \r \t \\ \x<ˇ c´ ıslo> \<ˇ c´ ıslo>

apostrof alert – p´ıpnut´ı ˇ (BS) backspace – posun zpet ´ nova´ stranka (FF) ´ nový ˇradek (LF, CRLF) ´ navrat voz´ıku (CR) ´ ı tabelator ´ horizontaln´ (HT) znak \ ´ ım cˇ ´ıslem hexadecimaln ´ eˇ znak s ordinaln´ ´ ım cˇ ´ıslem oktaloveˇ znak s ordinaln´

Pˇr´ıklady ’n’ IJC — Jazyk C

’\\’

’\n’

’\x80’

’\0’

’\’’ 35/252



´ literaly ´ V´ıceznakove´ a ’ˇsiroke’ Znakove´ konstanty anglický term´ın multi-byte character wide character wide character wide character

´ zapis ’xxx’ L’xxx’ u’xxx’ U’xxx’

typ int wchar_t char16_t char32_t

´ Poznamky: ´ ´ ı: ’\u03AF’, ’\U12345678’ UNICODE kodov an´ V´ıceznakova´ (multi-byte) reprezentace: UTF-8 ´ ´ ı zdrojoveho ´ ´ Kodov an´ kodu

IJC — Jazyk C

36/252



ˇ ezcov ˇ ´ Ret e´ literaly ˇ ezcov ˇ Ret e´ konstanty ´ zapis "" u8"" L"" u"" U""

typ char[] char[] wchar_t[] char16_t[] char32_t[]

ˇ Pˇrekladaˇc dopln´ı na konec ˇretezce znak ’\0’ ´ ˇ Pˇrekladaˇc pˇrekoduje obsah rˇetezce podle implementac´ı definovane´ lokalizace. Pouˇzije funkce mbstowcs, mbrtoc16 *, mbrtoc32 *

IJC — Jazyk C

37/252



ˇ ezcov ˇ ´ – pˇr´ıklady Ret e´ literaly ""

// pr´ azdn´ y ˇ retˇ ezec (char[1])

"text se znakem \" v ˇ retˇ ezci" " text \ pokraˇ cov´ an´ ı textu na n´ asleduj´ ıc´ ım ˇ r´ adku" "ˇ retˇ ezec1" <mezery, nov´ e ˇ r´ adky> "ˇ retˇ ezec2" // "ˇ retˇ ezec1ˇ retˇ ezec2" "\0" "12"

// char[4]: ’\0’ ’1’ ’2’ ’\0’

u8"nˇ eco" "a" "b" U"c" IJC — Jazyk C

// U"abc" 38/252



Deklarace datov´ y_typ

deklar´ ator [=ini_hodnota], ... ;

Pˇr´ıklady char void

line[100]; /* definice pole 100 znak˚ u */ f(void); /* deklarace funkce - prototyp */

void (*fp)(void); const char int double

IJC — Jazyk C

/* ukazatel na funkci */

backslash = ’\\’; i = 0; eps = 1.0e-5;

39/252



Okamˇzik inicializace ´ ı) promenn ˇ e´ se inicializuj´ı pˇri staticke´ (obvykle globaln´ pˇrekladu, bez inicializace maj´ı hodnotu 0 ´ ı) promenn ˇ e´ se inicializuj´ı, kdyˇz tok automaticke´ (lokaln´ ˇr´ızen´ı dosahne ´ m´ısta deklarace, bez inicializace maj´ı nedefinovanou hodnotu dynamicke´ (malloc()) nelze pˇr´ımo inicializovat Pˇr´ıklad int x; // inicializov´ ano pˇ ri pˇ rekladu na 0 void f(void) { int i; // i neinicializov´ ano int j = 1; // inicializov´ ano pˇ ri kaˇ zd´ em vol´ an´ ı char *p = malloc(100); // p inicializov´ ano // *p neinicializov´ ano } IJC — Jazyk C

40/252



Rozsah deklarace

´ ´ ı urovni identifikator deklarovaný na globaln´ ma´ rozsah od ´ ´ m´ısta deklarace do konce zdrojoveho textu modulu ´ ´ ı parametr funkce ma´ identifikator uvedený jako formaln´ ˇ funkce rozsah od m´ısta deklarace do konce tela ´ identifikator deklarovaný uvnitˇr bloku ma´ rozsah do konce bloku ´ eˇ ˇ st´ı ma´ rozsah funkce, ve ktere´ je definovano ´ nav ´ jmeno makra ma´ rozsah od pˇr´ıkazu #define do konce textu modulu nebo do pˇr´ıkazu #undef

IJC — Jazyk C

41/252



´ Viditelnost identifikatoru Pˇr´ıklad: int x = 10; int main() { double x = 1.1; printf("%f",x); return 0; } void printx(void) { printf("%d",x); }

IJC — Jazyk C

/* ve funkci plat´ ı double x */

/* zde plat´ ı int x */

42/252



typedef ´ ren´ı nových jmen (synonym) datových typu. Vytvaˇ ˚ ´ Nejde o vytvoˇren´ı noveho typu. Pˇr´ıklady typedef int length_t; length_t len, maxlen=100; typedef int (*ptr2f_t)(void); /* ukaz. na funkci */ ptr2f_t numcmp, swap; typedef char * string_t; string_t s, lineptr[10]; je ekvivalentn´ı: char *s, *lineptr[10]; IJC — Jazyk C

43/252



Ukazatel, adresa Deklarace/definice ukazatele int *px = NULL; ´ ı ukazatele na objekt (promennou) ˇ Z´ıskan´ int x, y; px = &x; // oper´ ator z´ ısk´ an´ ı adresy objektu ˇ Odkaz na objekt (promennou) y = *px;

// oper´ ator zpˇ r´ ıstupnˇ en´ ı objektu

px = &x; y = *px; // v tomto kontextu ekvivalent y = x Výskyt na leve´ straneˇ pˇriˇrazen´ı (pojem L-hodnota) *px = 0; *px += 4; (*px)++; IJC — Jazyk C

44/252



Pouˇzit´ı ukazatelu˚ ´ an´ ´ ı parametru˚ odkazem Pˇredav void f(char *s, int (*p)[3], void (*fp)(void)); ˇ an´ ´ ı pameti ˇ Dynamicke´ pˇridelov double *s = malloc(100*sizeof(double)); Dynamicke´ datove´ struktury // Linux lists: struct list_head queue = LIST_HEAD_INIT(queue); // ... struct list_head *pos; list_for_each(pos, queue) { struct node *d; d = list_entry(pos, struct node, head); d->data = 0; } IJC — Jazyk C

45/252



´ Adresový prostor – obrazek

IJC — Jazyk C

46/252



Ukazatele jako argumenty funkc´ı ´ ´ ena ˇ ˇ ych Pˇr´ıklad: Vzajemn a´ zam hodnot promenn´ void swap(int *px, int *py) { register int temp = *px; *px = *py; *py = temp; } Vol´ an´ ı: int x,y; /*...*/ swap(&x,&y); ^^^^^ pozor!

´ Poznamka: C++ a typ reference IJC — Jazyk C

47/252



Ukazatel a pole int a[10], *pa; pa = &a[0]; // ukazatel na prvn´ ı prvek pole x = *pa; // je ekvivalentn´ ı x = a[0] Ukazuje-li pa na i-tý prvek pole, potom (pa+1) ukazuje na prvek i+1. V naˇsem pˇr´ıkladu *(pa+1) je stejne´ jako a[1] ´ pa = a Je moˇzne´ m´ısto pa = &a[0] psat Obecneˇ plat´ı: a[i] == *(pa+i) a[i] == *(a+i) ´ Poznamky: Nen´ı moˇzne´ zapsat a++ Meze pol´ı se nekontroluj´ı IJC — Jazyk C

48/252



Adresova´ aritmetika ´ et ˇ aditivn´ı operace. S ukazateli lze provad ´ Jednotkou výpoˇctu je velikost c´ıloveho objektu. ´ Operace maj´ı smysl jen v ramci jednoho pole. Napˇr´ıklad: posun ukazatele o 1 prvek: p++ (vpˇred), p-- (vzad) posun ukazatele o N prvku: ˚ p+=5 (vpˇred o 5 prvku) ˚ rozd´ıl ukazatelu: ˚ p2 - p1 (poˇcet prvku˚ mezi ukazateli)

Pˇr´ıklad: Posun ukazatele na dalˇs´ı prvek pole int *ip = pole; ip++; // posun adresy o sizeof(int) bajt˚ u

IJC — Jazyk C

49/252



Omezen´ı operac´ı s ukazateli

´ ˇ posouvat ani Dva ukazatele nelze sˇc´ıtat, nasobit, delit, ˇ hlasit ´ chybu. kombinovat s float a double — pˇrekladaˇc by mel Pˇr´ıklady: Moˇzne´ chyby, ktere´ pˇrekladaˇc odhal´ı Pozor – chybne´ operace s ukazatelem const char *p1 = "abcdef"; const char *p2 = "ghijkl"; p1 += p2; // chyba - nesmysln´ a adresa p1 *= 2; // chyba - nesmysln´ a adresa p1 >>= 2; // chyba - nesmysln´ a adresa p1 += 3.14; // chyba - nesmysl

IJC — Jazyk C

50/252



´ ˇretezce ˇ Pˇr´ıklad: delka int strlen(const char *s) { int n; for(n=0; *s!=’\0’; s++) n++; return n; } ˇ s´ı varianta: Efektivnejˇ int strlen(const char *s) { const char *p = s; while( *p ) p++; return p-s; // rozd´ ıl ukazatel˚ u } ´ Poznamky: ´ ı f(&a[2]) resp. f(a+2) Je moˇzne´ i volan´ ˇ s´ı je obvykle strlen z knihovny. Nejefektivnejˇ IJC — Jazyk C

51/252



Pˇrehled povolených operac´ı: ptr+int, ptr+=int, ptr++ ptr-int, ptr-=int, ptr-ptr1 - ptr2 ptr[i] *ptr ptr1 = ptr2

posun posun rozd´ıl ´ ı indexovan´ ˇ ı c´ıle zpˇr´ıstupnen´ pˇriˇrazen´ı

ˇ ı: Upozornen´ Operace s neinicializovaným ukazatelem jsou nebezpeˇcne´ ˇ sinou kontrolovat pˇrekladaˇcem! a nelze je vetˇ Pozor – typicka´ chyba char *s; *s = ’A’;

IJC — Jazyk C

// Neinicializov´ ano nebo implicitn´ ı NULL // Z´ apis znaku na chybn´ e m´ ısto v pamˇ eti

52/252



ˇ ezce ˇ Ret ˇ ezec ˇ Ret je pole znaku, ˚ lze jej tedy ”pˇriˇradit”ukazateli: char *message = ""; // inicializace message = "Now is the time."; // nejde o kopii! ˇ Operace s rˇetezci: ˇ u: Kopie znakových ˇretezc ˚ char *strcpy(char *s1, const char *s2) char *s = s1; while( *s++ = *s2++ ); return s1; } ˇ ı: Upozornen´

{

´ obracen e´ poˇrad´ı parametru: ˚ strcpy(kam,odkud) ˇ u˚ (moˇzne´ buffer overflow) nekontroluje velikost ˇretezc ´ ı nedefinovano ´ chovan´ pro pˇrekrývaj´ıc´ı se s1 a s2 IJC — Jazyk C

53/252



ˇ ezce ˇ ´ ı Ret – pokraˇcovan´

ˇ u˚ s omezen´ım delky: ´ kopie ˇretezc char *strncpy(char *s1, const char*s2, size_t n); ´ ı rˇetezc ˇ u: spojovan´ ˚ char *strcat(char *s1, const char*s2); char *strncat(char *s1, const char*s2, size_t n); ´ ı porovnan´ ´ ı ˇretezc ˇ u: lexikaln´ ˚ int strcmp(const char*s1, const char *s2); int strncmp(const char*s1, const char *s2, size_t n); int strcoll(const char *s1, const char *s2); mnoho dalˇs´ıch funkc´ı (memcpy, strchr, strstr, strlen) viz std. rozhran´ı <string.h>

IJC — Jazyk C

54/252



ˇ a´ pole V´ıcerozmern ˇ pole (do libovolne´ urovn ˇ prvkem pole muˇ e) ˚ ze být opet ´ static int day_tab[2][13] = { { 0,31,28,31,30,31,30,31,31,30,31,30,31 }, { 0,31,29,31,30,31,30,31,31,30,31,30,31 }, }; ´ ıch prvky jsou uloˇzeny po rˇadc´ ´ sena chyba!) nelze zkracovat a[x][y] jako a[x,y] (nen´ı hlaˇ ´ ı vˇzdy odkazem parametry typu pole se pˇredavaj´ ´ ˇ nejlevejˇ ˇ s´ıho v parametrech nen´ı nutne´ udavat rozmer ´ u). indexu (poˇcet ˇradk ˚ Pro mapovac´ı funkci to nen´ı ´ (Pˇr´ıklad: int f(int day_tab[][13]); ) podstatne. parametr typu pole (T[]) je ekvivalentn´ı parametru typu ukazatel (T*) IJC — Jazyk C

55/252



Inicializace pole ukazatelu˚ const char *month_name(int n) { // pole ukazatel˚ u na ˇ retˇ ezce static const char *name[] = { "illegal month", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; return (n<1 || n>12)? name[0] : name[n]; } ´ Poznamka: char a[10][20]; // pole znakov´ ych pol´ ı char *b[10]; // pole ukazatel˚ u na ˇ retˇ ezce IJC — Jazyk C

56/252



´ ˇradku ´ Argumenty pˇr´ıkazoveho (command line) ˇ ı: Programu TEST lze zadat argumenty pˇri spuˇsten´ TEST argument1 argument2 .... posledn´ ı_argument argv[0] argv[1] argv[2] argv[argc-1] ´ argv[0] je jmeno programu (nebo ""), argv[argc] ma´ hodnotu NULL Pˇr´ıklad: Výpis argumentu˚ – program echo int main(int argc, char *argv[]) { for(int i=1; i<argc; i++) printf("%s ", argv[i]); printf("\n"); return 0; } IJC — Jazyk C

57/252



Druha´ (horˇs´ı) varianta výpisu argumentu˚ int main(int argc, char *argv[]) { while(--argc>0) printf("%s ", *++argv); // ˇ spatnˇ e ˇ citeln´ e printf("\n"); return 0; } ´ argumentu˚ ´ Poznamka: getopt a ruzn ˚ e´ formaty program program program program program IJC — Jazyk C

-i -i hodnota -i=hodnota --include hodnota --include[=hodnota] 58/252



Struktury struct Date { unsigned char day; unsigned char month; int year; }; struct Date d = {21,10,1993}; struct Date dat2; Odkaz na cˇ len struktury: jm´ eno_promˇ enn´ e . jm´ eno_ˇ clenu Pˇ r´ ıklad: x = d.year Je moˇzne´ vnoˇren´ı struktur ´ Struktury lze pˇredavat jako parametry funkc´ım a vracet jako funkˇcn´ı hodnotu IJC — Jazyk C

59/252



Struktury – omezen´ı Povolene´ operace jsou pouze: ˇ ı poloˇzky . zpˇr´ıstupnen´ = pˇriˇrazen´ı (nebo inicializace) ´ ı ukazatele na promennou ˇ & z´ıskan´ ´ Ostatn´ı operace jsou zakazan e´ (struktury nelze sˇc´ıtat atd., ´ ´ Poznamka: v C++ lze definovat potˇrebne´ operatory) Anonymn´ı struktury a unie (C11) struct X { int x; struct Anonymous { int y; }; } s; s.y = 1; IJC — Jazyk C

60/252



Neupln ´ a´ deklarace struktury: struct ABC; Lze pouˇz´ıt pro definici ukazatelu: ˚ struct ABC *p; ˇ e: ´ Nelze pouˇz´ıt pro definici promenn struct ABC x; /* chyba */ Pouˇzit´ı ukazatele na strukturu struct Date *uk = &d; x = uk->year; je ekvivalentn´ı pˇr´ıkazu x = (*uk).year; ´ ´ u) Operatory . a -> maj´ı vysokou prioritu (viz tabulka operator ˚ ++uk->day je ekvivalentn´ı ++(uk->day) IJC — Jazyk C

61/252



Velikost struktury v bajtech sizeof(struct XYZ) sizeof(dat1) sizeof dat1 // bez z´ avorek jen pro v´ yrazy Velikost struktury nemus´ı být souˇctem velikost´ı jednotlivých ´ ı (alignment) poloˇzek i poloˇzek. Duvodem je zarovnan´ ˚ ´ celkove velikosti struktury. ´ ı celých Pozor na vloˇzene´ m´ısto (padding) – pˇri kop´ırovan´ struktur (memcpy, fwrite, ...) je moˇzný unik informac´ı. ´ ´ Poznamky: Little endian / big endian, _Alignof(type-name) _Alignas(type-name) _Alignas(const-expr) IJC — Jazyk C

62/252



´ ı slov v textu ... Pˇr´ıklad – poˇc´ıtan´ Struktura muˇ ˚ ze obsahovat ukazatel na sebe: struct treenode { char *word; // ˇ retˇ ezec int count; struct treenode *left; // lev´ y n´ asledn´ ık struct treenode *right; // prav´ y n´ asledn´ ık }; int main() { // ne´ upln´ a implementace struct treenode *root = NULL; char word[MAXWORD]; int t; while( (t=getword(word, MAXWORD)) != EOF) if(t>0) root = tree_insert(root,word); tree_print(root); } IJC — Jazyk C

63/252



Pˇr´ıklad – ... vloˇzen´ı do stromu struct treenode * tree_insert(struct treenode *p, const char *w) { int cond; if( p == NULL ) { // nov´ e slovo p = tree_alloc(); // malloc s kontrolou NULL p->word = strdup(w); p->count = 1; p->left = p->right = NULL; } else if( (cond=strcmp(w,p->word)) == 0 ) p->count++; // == slovo se opakuje else if( cond<0 ) // < do lev´ eho podstromu p->left = tree_insert(p->left,w); else // > do prav´ eho podstromu p->right = tree_insert(p->right,w); return p; } IJC — Jazyk C

64/252



Bitova´ pole (bitfields) ˇ Vhodne´ pro usporn e´ uloˇzen´ı dat na nekolika bitech ´ Lze pouˇz´ıt pouze uvnitˇr struktur (a uni´ı) Pˇr´ıklad: struct flags { unsigned is_kw : unsigned is_ext : unsigned : unsigned is_stat : unsigned : unsigned num_bit : } flags; // velikost

IJC — Jazyk C

1; // uloˇ zeno v jednom bitu 1; 2; // v´ yplˇ n 2 bity 1; 0; // zarovn´ an´ ı na unsigned 8; // uloˇ zeno v 8 bitech 2*unsigned

65/252



´ ı Bitova´ pole – pokraˇcovan´

Nevýhody: ´ ´ ı adresy) Nelze pouˇz´ıt operator & (z´ıskan´ ´ Pomalejˇs´ı pˇr´ıstup k poloˇzkam ´ ı bitu˚ (od LSB nebo od MSB) nen´ı Poˇrad´ı obsazovan´ ´ normou definovano = nepˇrenositelne´ ´ Poznamka: Lze nahradit explicitn´ı prac´ı s bitovými operacemi

IJC — Jazyk C

66/252



Unie (1.p union) ´ Vˇsechny poloˇzky zaˇc´ınaj´ı na stejne´ adrese (zaˇcatek unie) a pˇrekrývaj´ı se. Platna´ (aktivn´ı) je vˇzdy jen jedna poloˇzka. Pouˇzit´ı sloˇzek je stejne´ jako u struktur Inicializovat lze pouze prvn´ı sloˇzku (C90), podle C99+ jakoukoli sloˇzku { .name = value } Pˇr´ıklad: union u_tag { int ival; float fval; char *pval; } u;

if(typ==INT) printf("%d\n", u.ival); else if(typ==FLOAT) printf("%f\n", u.fval); else if(typ==STRING) printf("%s\n", u.pval); else error("chyba"); union u_tag x = { 1 }; //C99+: = { .fval = 0.1 };

IJC — Jazyk C

67/252



Ukazatel na funkci ´ obsahuje adresu kodu funkce, ´ ı funkce (ukazatelova´ aritmetika muˇ ˚ ze být pouˇzit pouze k volan´ ´ Ukazatel: nen´ı pouˇzitelna). T (*fp)(void); reprezentuje ukazatel na funkci bez parametru˚ vracej´ıc´ı typ T. ´ Mame-li funkci: T funkce(void) { /* k´ od funkce */ } potom pˇriˇrazen´ı do ukazatele ma´ v ANSI C tvar: fp = &funkce;

// & lze vynechat

´ ı funkce: Pouˇzit´ı ukazatele k volan´ (*fp)(); fp(); IJC — Jazyk C

// vol´ an´ ı c´ ılov´ e funkce // lze zkr´ atit 68/252



Pˇr´ıklad – ˇrazen´ı pole ukazatelu˚ ... //***** ˇ radic´ ı algoritmus - netestov´ ano, doladit! void sort( void *v[], unsigned n, int (*cmp)(const void *p1, const void *p2)) { int gap, i, j; for( gap=n/2; gap>0; gap/=2 ) for( i=gap; i=0; j-=gap ) { void *tmp; if(cmp(v[j],v[j+gap]) <= 0) // porovn´ an´ ı break; tmp = v[j]; // swap v[j] = v[j+gap]; v[j+gap] = tmp; } } IJC — Jazyk C

69/252



Pˇr´ıklad – dokonˇcen´ı

Pˇr´ıklad: ˇrazen´ı pole ukazatelu˚ – pouˇzit´ı: char *lineptr[100]; // pole ˇ retˇ ezc˚ u int nlines; .... sort(lineptr,nlines,&strcmp); ^^^^^^^ probl´ em: konverze kde int strcmp(const char *s1, const char *s2); je standardn´ı funkce z knihovny (viz <string.h>). ´ Poznamka: Standardn´ı knihovna obsahuje qsort()

IJC — Jazyk C

70/252



Výcˇ tový typ Konstanty ve výcˇ tu jsou typu int a maj´ı hodnoty rostouc´ı postupneˇ od nuly Lze explicitneˇ specifikovat hodnoty poloˇzek (konstant) ˇ e´ výcˇ toveho ´ Promenn typu jsou kompatibiln´ı s typem int Oznaˇcen´ı (tag) výcˇ tu nesm´ı kolidovat: struct A {}; enum A {}; union A {}; je chyba! Pˇr´ıklady enum dny { PO, UT, ST, typedef enum Boolean { enum bitmask { bit0=1, bit2=4, enum { RAZ, DVA, TRI } IJC — Jazyk C

CT, PA, SO, NE }; FALSE, TRUE } Boolean; LSB=bit0, bit1, bit3=8, bit4=16 }; e; // promˇ enn´ a 71/252



Pouˇzit´ı výcˇ tu

Pˇr´ıklad: enum dny d=PO; int i = d; d++; printf("%d", d); d = 2;

// hodnota 0 // pˇ riˇ cte 1 // vytiskne 1

ˇI ´VAT! // v C pˇ r´ ıpustn´ e, ale NEPOUZ

´ Poznamka: V C++0x jsou i lepˇs´ı výcˇ tove´ typy (enum class)

IJC — Jazyk C

72/252



´ Operatory

´ Aritmeticke´ operatory + * / %

´ ı i unarn´ ´ ı) (binarn´ modulo

´ ´ Pro komutativn´ı operatory nen´ı definovano poˇrad´ı vyhodnocen´ı operandu˚ ´ ´ Pozor na operator % a na výpoˇcty v plovouc´ı cˇ arce ´ Relaˇcn´ı operatory == != <

IJC — Jazyk C

>

<=

>=

73/252



´ ´ ı Operatory – pokraˇcovan´ ´ Logicke´ operatory || && !

logicke´ nebo (OR) logicke´ a (AND) logicke´ ne (NOT)

´ ´ ı: Zkracen e´ vyhodnocovan´ A || B je-li A!=0, pak se B nevyhodnocuje A && B je-li A==0, pak se B nevyhodnocuje Pˇr´ıklad: (year%4 == 0 && year%100 != 0 || year%400 == 0)

IJC — Jazyk C

74/252



Implicitn´ı konverze typu˚

Celoˇc´ıselna´ rozˇs´ırˇen´ı (integral promotions): ´ ı hodnotu vˇcetneˇ znamenka ´ zachovavaj´ char, short int, bitova´ pole → int nebo unsigned ´ Poznamka: argumenty funkc´ı (...), K&R float → double ´ ıch aritmetických Obvykle´ aritmeticke´ konverze u binarn´ operac´ı: 1

2 3

IJC — Jazyk C

Je-li jeden operand typu long double, je druhý pˇreveden na long double a výsledek je take´ long double jinak, je-li double ... jinak, je-li float ...

75/252



´ ı Implicitn´ı konverze typu˚ – pokraˇcovan´

Jinak se provedou celoˇc´ıselna´ rozˇs´ıˇren´ı pro oba operandy a potom: 1

2

3

4

5

IJC — Jazyk C

´ ı se dalˇs´ı jestliˇze oba operandy maj´ı stejný typ neprovad´ konverze, jinak, jsou-li oba operandy signed nebo oba unsigned ˇ s´ım rozsahem. pˇrevede se vˇse na typ s vetˇ ˇ s´ı nebo stejný rozsah, je Jinak, jestliˇze unsigned typ ma´ vetˇ druhý operand pˇreveden na unsigned. Jinak, jestliˇze signed operand muˇ ˚ ze reprezentovat vˇsechny hodnoty unsigned operandu, je druhý operand pˇreveden na signed. Jinak jsou oba pˇrevedeny na odpov´ıdaj´ıc´ı unsigned typ.

76/252



´ signed/unsigned char Problem – vznika´ pˇri pˇrevodu znaku˚ na int: signed char → int rozsah −128 .. 127 unsigned char → int rozsah 0 .. 255 Pˇr´ıklad: int getchar(void); /* vrac´ ı EOF (tj. -1) nebo znak 0 .. 255 int c; c = getchar(); if(c==EOF) ....

IJC — Jazyk C

*/

/* mus´ ı b´ yt typu int !!! */ /* pro char c; bude chybn´ e */

77/252



Explicitn´ı konverze

(typ) v´ yraz ´ kontextove´ operace delen´ ˇ ı Pˇr´ıklad: problem int i1,i2; double f; ... f = i1/i2; f = (double)i1/i2;

// celoˇ c´ ıseln´ e dˇ elen´ ı

f = i1/(i2+1.0)

IJC — Jazyk C

78/252



´ ´ ı Operatory – pokraˇcovan´ ´ Operatory ++ a -++ --

increment (zvýsˇ en´ı o 1) decrement (sn´ızˇ en´ı o 1)

++i i++

pˇred pouˇzit´ım hodnoty po pouˇzit´ı hodnoty

´ prefixový zapis ´ postfixový zapis

Pˇr´ıklad: int x, n=5; x = n++; x = ++n;

/* x = 5, n = 6 */ /* x = 7, n = 7 */

´ ı operatory ´ ´ Poznamka: Tyto unarn´ lze pouˇz´ıt pouze pro ˇ e! ´ (pˇresneji: ˇ L-hodnoty). promenn Nelze napˇr´ıklad napsat (55+5)++ IJC — Jazyk C

79/252



Pˇr´ıklad

ˇ ı zadaneho ´ ˇ Pˇr´ıklad: odstranen´ znaku z ˇretezce int squeeze( char s[], char c ) { int i,j; for( i=j=0; s[i] != ’\0’; i++ ) if( s[i] != c ) s[j++] = s[i]; s[j] = ’\0’; }

IJC — Jazyk C

80/252



´ ´ ı Operatory – pokraˇcovan´ ´ Logicke´ operatory po bitech & | ^ ~

bitove´ AND (bitwise and) bitove´ OR bitove´ XOR bitova´ negace (NOT)

Posuny bitu˚ << >>

posun vlevo posun vpravo

´ Poznamka: unsigned operand: logický posun, ´ signed operand: nedefinovano/aritmetick´ y posun IJC — Jazyk C

81/252



Pˇr´ıklad

´ ˇ e´ Pˇr´ıklad: cˇ ten´ı bitoveho pole z promenn int getbits(unsigned x, return (x>>(p+1-n)) & } | | \----------/ posun na prav´ y okraj slova

unsigned p, unsigned n) { ~( ~0 << n) ; | | \---------/ maska 000000111111 n jedniˇ cek

´ Jak se vyhnout zavislosti na poˇctu bitu˚ slova: ´ ´ ´ ´ (nezavisl e) ~0 = same jedniˇcky ve sloveˇ libovolne´ delky ´ ´ x & ~077 nezavisl e´ na delce slova ´ x & 017700 zavisl e´ – uvaˇzuje 16 bitu˚

IJC — Jazyk C

82/252



´ ´ ı Operatory – pokraˇcovan´ ´ Pˇriˇrazovac´ı operatory a vyrazy ´ +=

-=

*=

/=

%=

<<=

>>=

&=

^=

|=

Pˇriˇrazen´ı ma´ hodnotu a typ leve´ strany. c1 op= c2 je ekvivalentn´ı c1 = c1 op (c2) ´ Pˇr´ıklad: (pozor na zavorky) x *= y + 1

x = x * (y + 1)

Nen´ı nutne´ optimalizovat spoleˇcne´ podvýrazy, ˇ s´ı: cˇ asto je cˇ itelnejˇ yyval[yypv[p3+p4]+yypv[p1+p2]] += 2; IJC — Jazyk C

83/252



Pˇr´ıklad: souˇcet jednotkových bitu˚ int bitcount(unsigned n) { int b; for( b=0; n != 0; n >>= 1 ) if(n & 1) // hodnota nejniˇ zˇ s´ ıho bitu b++; return b; } ´ Poznamka: Pozor na vedlejˇs´ı efekty i = i++; pole[j] = pole[k]++;

IJC — Jazyk C

// nedefinov´ ano! // nedefinov´ ano pro j==k

84/252



´ ´ ı Operatory – pokraˇcovan´ ˇ y výraz Podm´ınen´ e1 ? e2 : e3 Je-li e1!=0, pak výraz ma´ hodnotu e2, jinak e3 Vyhodnocuje se pouze jeden z výrazu˚ e2, e3 ´ an´ ´ ı tisku Pˇr´ıklad: formatov for(int i=0; i < N; i++) printf("%6d%c", a[i], (i%10==9||i==N-1)?’\n’:’ ’); Pˇr´ıklad: funkce max int max(int a, int b) { return (a>b) ? a : b; } IJC — Jazyk C

85/252



´ u˚ Priorita a asociativita operator ´ operatory asociativita ( ) [ ] -> . → ! ~ + - ++ -- & * (typecast) sizeof ← * / % → + → << >> → < <= > >= → == != → & → ^ → | → && → || → ?: ← = *= /= %= += -= &= ^= |= <<= >>= ← , → ´ u˚ ´ Poznamka: je moˇzne´ pˇreskupen´ı komutativn´ıch operator

IJC — Jazyk C

86/252



Pˇr´ıkazy Vyraz-pˇ ´ r´ıkaz ˇ stˇredn´ık. Výraz se stane pˇr´ıkazem, zap´ısˇ eme-li za nej ´ ´ Hodnota takoveho výrazu se zanedba. Pˇr´ıklad: x = 0; i++; printf("xxx"); Sloˇzeny´ pˇr´ıkaz – blok { deklarace pˇ r´ ıkaz1 pˇ r´ ıkaz2 .... pˇ r´ ıkazN } ´ Poznamky: Za } nen´ı stˇredn´ık! (pozor na makra) ˇ ych mohou být mezi pˇr´ıkazy C99: deklarace promenn´ IJC — Jazyk C

87/252



´ ı Pˇr´ıkazy – pokraˇcovan´

ˇ y´ pˇr´ıkaz Podm´ınen if( v´ yraz ) pˇ r´ ıkaz1 [ else pˇ r´ ıkaz2 ] ´ Poznamka: nejednoznaˇcnost se rˇeˇs´ı jako v Pascalu a jiných ´ jazyc´ıch: else patˇr´ı k posledn´ımu volnemu if

IJC — Jazyk C

88/252



´ ı vyhledav ´ an´ ´ ı Pˇr´ıklad: binarn´ /* hled´ ame x v poli v[] o rozmˇ eru n */ int binary( int x, int v[], int n) { int low = 0; int mid; int high = n - 1; while( low<=high ) { mid = (low + high) / 2; if( xv[mid] ) low = mid + 1; else return mid; /* nalezeno mid */ } return -1; /* nenalezeno */ } IJC — Jazyk C

89/252



´ ı Pˇr´ıkazy – pokraˇcovan´

Pˇr´ıkaz switch switch( v´ yraz ) { case konstantn´ ı_v´ yraz : pˇ r´ ıkaz1 .... [ default : pˇ r´ ıkazNPLUS1; ] } ´ Poznamka: Pozor: funguje jinak neˇz v Pascalu!

IJC — Jazyk C

90/252



´ ı cˇ ´ıslic, prazdn´ ´ Pˇr´ıklad: poˇc´ıtan´ ych znaku˚ a ostatn´ıch int main() { int c, i, nwhite=0, nother=0, ndigit[10] = { 0, }; while( (c=getchar()) != EOF ) switch(c) { case ’0’: case ’1’: case ’2’: case ’3’: case ’4’: case ’5’: case ’6’: case ’7’: case ’8’: case ’9’: ndigit[c-’0’]++; break; /* nepokraˇ covat */ case ’ ’: case ’\n’: case ’\t’: nwhite++; break; /* ukonˇ c´ ı switch */ default : nother++; break; /* i zde je dobr´ e */ } /* switch i while */ printf("digits = "); for(i=0; i<10; i++) printf(" %d ", ndigit[i]); printf("\n ws=%d, other=%d\n", nwhite, nother); } IJC — Jazyk C

91/252



´ ı Pˇr´ıkazy – pokraˇcovan´ Cyklus while while ( ) Cyklus for for( ; ; ) for(;;)

// nekoneˇ cn´ y cyklus

for(int i=0; i
IJC — Jazyk C

92/252



´ ı Pˇr´ıkazy – pokraˇcovan´ Pˇr´ıklad: ˇrazen´ı vzestupneˇ (shell-sort) /* funkce ˇ rad´ ı pole v[] o rozmˇ eru n vzestupnˇ e */ void shell(int v[], int n) { int gap, i, j, temp; for( gap=n/2; gap>0; gap/=2) for( i=gap; i=0 && v[j]>v[j+gap]; j-=gap) { temp = v[j]; v[j] = v[j+gap]; v[j+gap] = temp; } } IJC — Jazyk C

93/252



´ ı Pˇr´ıkazy – pokraˇcovan´ ´ ´ Operator cˇ arka – postupne´ vyhodnocen´ı výrazu, ˚ pouˇzit´ı posledn´ıho ´ ˇ Pˇr´ıklad: obracen´ ı ˇretezce na m´ısteˇ void reverse(char s[]) { int i, j; for( i=0, j=strlen(s)-1; i<j; i++, j--) { int c = s[i]; s[i] = s[j]; s[j] = c; } } ´ ˇ ıc´ı argumenty funkc´ı nejsou ´ Poznamka: cˇ arky oddeluj´ ´ operatory! IJC — Jazyk C

94/252



´ ı Pˇr´ıkazy – pokraˇcovan´ Cyklus do-while do pˇ r´ ıkaz while( v´ yraz );

// cykl´ ı dokud podm´ ınka plat´ ı

´ Poznamky: Provede se alesponˇ jednou Podle statistik cca 5% cyklu˚ ´ poˇrad´ı Pˇr´ıklad: konverze cˇ ´ısla na znaky v opaˇcnem do { s[i++] = n % 10 + ’0’; }while( (n/=10) > 0 ); IJC — Jazyk C

95/252



Pˇr´ıkaz break Ukonˇcuje nejbl´ızˇ e nadˇrazený pˇr´ıkaz switch, while, for, nebo do-while ´ ı koncových mezer a tabulator ´ u˚ Pˇr´ıklad: vynechan´ int main() { int n; char line[MAXLINE]; while( (n=getline(line,MAXLINE)) > 0 ) while( --n >= 0 ) if( !isspace(line[n]) ) break; line[n+1] = ’\0’; printf("%s\n", line); } return 0; } IJC — Jazyk C

{

96/252



Pˇr´ıkaz continue

ˇ cyklu a pokraˇcuje podm´ınkou cyklu Pˇreskoˇc´ı zbytek tela for( i=0; i= 0 */ }

ˇ cyklu ´ Poznamka: Eliminace zanoˇren´ı tela

IJC — Jazyk C

97/252



´ eˇ ˇ st´ı Pˇr´ıkaz goto a nav ´ Pouˇzitelne´ pouze v ramci jedne´ funkce void f() { // .... goto identifik´ ator; // .... identifik´ ator : pˇ r´ ıkaz; // .... } ´ Poznamky: ˇ minimalizovat pouˇzit´ı Pouˇz´ıvat opatrne, ´ Nikdy neskakat do strukturovaných pˇr´ıkazu˚

IJC — Jazyk C

98/252



Pˇr´ıklad – prakticke´ pouˇzit´ı skoku int f() { for (....) for (....) { // 2. ´ uroveˇ n // .... if (chyba) goto error; // .... } return kladny_vysledek; error: // oˇ setˇ ren´ ı chyby return -1; }

IJC — Jazyk C

99/252



Funkce typ jm´ eno ( deklarace_parametr˚ u ) { deklarace lok´ aln´ ıch promˇ enn´ ych pˇ r´ ıkazy // C99: i deklarace } Funkce muˇ ˚ ze vracet struktury, unie ale ne pole Pˇr´ıkaz return return; /* u funkce void f() */ return e; /* e=v´ yraz kompatibiln´ ı s typem fce */ ´ Poznamky: C99+: inline funkce, C11: _Noreturn IJC — Jazyk C

100/252



Rekurze viz Rekurze. ´ Pˇr´ıklad: výpis celeho cˇ ´ısla des´ıtkoveˇ void printd(int n) { int i; if(n<0) { putchar(’-’); n = -n; } if((i=n/10) != 0) printd(i); // rekurze putchar(n%10 + ’0’); } ´ Poznamka: tail recursion IJC — Jazyk C

101/252



Argumenty funkc´ı

´ any ´ hodnotou jsou pˇredav ´ ı odkazem (ukazatel na prvn´ı prvek) pole se pˇredavaj´ ´ ˇ ym poˇctem argumentu˚ problemy s funkcemi s promenn´ C99: __func__, ... ´ Poznamka: API, ABI

IJC — Jazyk C

102/252



´ ı Argumenty funkc´ı – pokraˇcovan´ ˇ ym ˇ Funkce s promenn ´ poctem argumentu˚ typ f(typ1 parametr1, ... ); // variadic function Mus´ı být alesponˇ jeden pevný parametr ´ poˇctu argumentu˚ Funkce mus´ı m´ıt informace o skuteˇcnem ´ ı pˇri zavolan´ va_list, va_start(), va_arg(), va_end() ˇ ym poˇctem argumentu˚ Pˇr´ıklad: Standardn´ı funkce s promenn´ int printf(const char *fmt, ... ); int sprintf(char *s, const char *fmt, ... ); IJC — Jazyk C

103/252



ˇ e´ Extern´ı promenn ´ ıch promenn´ ˇ ych a funkc´ı Program = mnoˇzina globaln´ ´ ı promenn ˇ e´ Globaln´ ˇ e´ Jsou to staticke´ promenn Inicializace ”pˇri pˇrekladu” (Pouˇzit´ı napˇr. pro omezen´ı poˇctu argumentu˚ funkc´ı) ´ Deklarace funkce je implicitneˇ extern´ı (extern je zbyteˇcne): extern int plus(int,int);

int plus(int,int);

ˇ ych je podstatný rozd´ıl: U promenn´ extern int a;

int a; // definice

Pouˇzit´ı: extern deklarace pˇred pouˇzit´ım, modularita ´ Poznamka: C89: nedeklarovane´ funkce: extern int f(); IJC — Jazyk C

104/252



Rozsah platnosti

(scope) ´ ´ je jmeno ´ Usek programu, ve kterem definovane´ ˇ e´ blok automaticke´ promenn ´ ı promenn ˇ e´ globaln´ od deklarace do konce souboru ´ jmena parametru˚ prototyp, funkce ´ eˇ ˇ st´ı nav funkce

IJC — Jazyk C

105/252



ˇ e´ Staticke´ promenn existuj´ı trvale bez ohledu na aktivaci funkc´ı ˇ a´ nebo funkce oznaˇcena´ static je platna´ Pozor: promenn ´ pouze v ramci souboru (modulu) a nen´ı viditelna´ z jiných modulu˚ Pˇr´ıklad: int count; static char buffer[100]; static int plus(int a, int b) { static int s = 1; int n = a + buffer[b]; return s = (n + count*s); } IJC — Jazyk C

// statick´ a a extern´ ı // statick´ a a ne-extern´ ı // statick´ a=ne-extern´ ı // statick´ a a lok´ aln´ ı // automatick´ a=lok´ aln´ ı

106/252



ˇ e´ register Promenn ´ jsou uloˇzeny v registru procesoru Pokud je to moˇzne, (rychlost) ˇ e´ Pouze pro automaticke´ promenn ˇ Nelze z´ıskat ukazatel na registrovou promennou Pˇr´ıklad: int swap(int *x, int *y) { register int tmp = *x; *x = *y; *y = tmp; }

IJC — Jazyk C

107/252



Blokova´ struktura programu ´ urovn ˇ Hierarchie bloku˚ (zanoˇren´ı do ”libovolne” e) ´ ˇ e´ V bloku lze deklarovat promenn ´ ı deklarace pˇrekrýva´ ostatn´ı (globaln´ ´ ı i lokaln´ ´ ı), plat´ı Lokaln´ ´ ´ ıch parametru˚ to i pro jmena formaln´ ´ Poznamky: Nelze vnoˇrovat definice funkc´ı ´ Makra nerespektuj´ı tuto strukturu (nejsou ”hygienicka”)

IJC — Jazyk C

108/252



ˇ ych Inicializace promenn´ ´ Staticke´ jsou (”pˇri pˇrekladu”) implicitneˇ inicializovany ˇ hodnotou nula, pˇr´ıpadna´ inicializace probehne pˇri pˇrekladu (vyˇzaduje konstantn´ı výraz) const int nula; static int dva = 2; void f(int p) { static bool stav=true; // mus´ ı b´ yt konstanta // .... } Automaticke´ a registrove´ maj´ı nedefinovanou hodnotu, ˇ pˇr´ıpadna´ inicializace se provede pˇri behu programu void g(int v[], int n) { int x; // nedefinovan´ a hodnota int high = v[n-1]; // nemus´ ı b´ yt konst. v´ yraz // .... } IJC — Jazyk C

109/252



ˇ ych Pˇr´ıklady inicializace strukturovaných promenn´ Inicializace pol´ı int pole1[] = { 1, 1, 1, 0, 0, }; int pole2[10] = { 1, [5]=0, 1, }; // jen C99+ char string1[] = "the"; // pouˇ zit´ ı ˇ retˇ ezce char string2[] = { ’t’, ’h’, ’e’, ’\0’ }; char nonstring[3] = "the";

// nen´ ı ˇ retˇ ezec!

Inicializace struktur struct MyExtraComplex { double Re; int Im; } c1 = { .Re=1.25, .Im=3 }; // C99 inicializace IJC — Jazyk C

110/252



Pˇrekladove´ jednotky (moduly) Modul je samostatna´ pˇrekladova´ jednotka – soubor *.c Pˇr´ıklad:

´ styl – hroz´ı nekonzistence pozor, NEVHODNY

// === modul1.c === // === modul2.c === int x; // definice x extern int x; // deklarace x static int s; static int s; void f2(double d); int main() { f2(5); s--; return 0; }

static void f(void) { s++; } void f2(double d) { x = 10*d; f(); }

Pˇreklad a sestaven´ı v´ıce modulu: ˚ cc modul1.c modul2.c IJC — Jazyk C

111/252



´ e´ ˇreˇsen´ı Pˇrekladove´ jednotky – spravn ˇ ı rozhran´ı v souboru *.h (header file). Moduly zveˇrejnuj´ V rozhran´ı jsou pouze: ˇ ych deklarace promenn´ deklarace funkc´ı definice typu˚ definice maker definice inline funkc´ı

(Jen pokud jsou sd´ılene´ v´ıce moduly.) ´ a´ (#include) do modulu, Rozhran´ı se vklad ˚ aby byla pˇri ˇ pˇrekladu zajiˇstena konzistence deklarac´ı a kontrola definic. ´ Poznamka: Aby to opravdu fungovalo, potˇrebujete ´ eˇ pouˇz´ıt program ”make”nebo podobný. spravn

IJC — Jazyk C

112/252



´ e´ ˇreˇsen´ı 2 Pˇrekladove´ jednotky – spravn // === rozhrani.h === extern int x; void f2(double d); // === modul1.c === #include "rozhrani.h" static int s; int x; /* definice */ int main() { f2(5); s--; return 0; }

IJC — Jazyk C

// === modul2.c === #include "rozhrani.h" static int s; static void f(void) { s++; } void f2(double d) { x = 10*d; f(); } 113/252



Preprocesor jazyka C Direktivy zaˇc´ınaj´ı znakem # v prvn´ım sloupci Vloˇzen´ı souboru s rozhran´ım #include <stdio.h> #include "modul2.h"

// hled´ a i v ./

Definice makra bez parametru˚ #define JMENO

text \ text na dalˇ s´ ım ˇ r´ adku // ... kaˇ zd´ y v´ yskyt JMENO se rozvine na text #undef JMENO Pˇr´ıklad: #define EOF -1 #define NULL ((void*)0) IJC — Jazyk C

114/252



Makra s parametry Pˇr´ıklad: pozor na priority a vedlejˇs´ı efekty #define SQR(a) ((a)*(a)) // pouˇ zit´ ı: x = SQR(p+q); // ((p+q)*(p+q)) O.K. x = SQR(i++); // ((i++)*(i++)) nedefinov´ ano #define ABS(a)

( ((a)<0) ? -(a) : (a) )

#define PRIKAZ(x) do { neco(x); } while(0) //.... if(a) PRIKAZ(a); else PRIKAZ(b);

IJC — Jazyk C

115/252



ˇ y pˇreklad Podm´ınen´ ´ ı usek Vynechan´ u˚ programu ´ #ifdef JMENO ..... #endif /* JMENO */

#ifndef JMENO ..... #endif /* !JMENO */

#if konstantn´ ı_v´ yraz ..... #elif konstantn´ ı_v´ yraz ..... #else ..... #endif V podm´ınce jsou pouˇzitelne´ pouze konstantn´ı výrazy: defined(linux) && defined(i386) __BORLANDC__ >= 0x0300 IJC — Jazyk C

116/252



´ ı parametru˚ a vytvaˇ ´ ren´ı ˇretezc ˇ u˚ Spojovan´

# ##

ˇ vytvoˇren´ı ˇretezce (”stringize”) ´ u˚ spojen´ı identifikator

´ Pˇr´ıklad: ukazka pouˇzit´ı #define SPOJ(a,b) #define PRINT(x)

a##b printf(#x " = %d\n", x)

Pouˇzit´ı a výsledek: SPOJ(file,id) PRINT(pocet)

IJC — Jazyk C

fileid printf("pocet" " = %d\n", pocet)

117/252



Parametry pˇrekladu Nastaven´ı ruzn´ ˚ ych parametru˚ pˇrekladu: #pragma

<parametry>

Pˇr´ıklad: Borland C / DOS #pragma option -K #pragma warn amb

/* unsigned char */

Pˇr´ıklad: GCC #pragma message "Compiling " __FILE__ "..." #pragma GCC optimize ("-O1")

´ Poznamka: _Pragma IJC — Jazyk C

118/252


a c e f l m s t

Standardn´ı ISO-C knihovny soubor assert.h ctype.h errno.h float.h limits.h locale.h math.h setjmp.h signal.h stdarg.h stddef.h stdio.h stdlib.h string.h time.h IJC — Jazyk C

co obsahuje ˇ ı. Makro assert pro laden´ Makra pro klasifikaci znaku. ˚ ´ ı chybových kod ´ u. Definuje pojmenovan´ ˚ Parametry pro floating-point funkce. Rozsahy celých cˇ ´ısel. ´ Funkce pro narodn´ ı/jazykovou podporu. ´ Matematicke funkce. Typy pro funkce longjmp a setjmp. Konstanty a deklarace pro funkce signal a raise ´ s promenn´ ˇ ym poˇctem argumentu. Makra pro praci ˚ ˇ Nekter a´ makra a datove´ typy. Typy,makra a funkce pro standardn´ı vstup/výstup Obecneˇ pouˇzitelne´ funkce (konverze, ˇrazen´ı) ´ s ˇretezci ˇ ˇ ı. Funkce pro praci a pamet´ ´ s cˇ asem. Typy a funkce pro praci 119/252


a c e f l m s t

ˇ ı assert.h – Makro pro laden´ Implementace: #define assert(podminka) if(!podminka) ..... ´ ı podm´ınek diagnostika logických chyb – testovan´ (precondition, postcondition) ˇ ı podm´ınky vyp´ısˇ e: pˇri nesplnen´ text "Assertion failed: " text podm´ınky x < 0 ´ jmeno souboru __FILE__ ˇc´ıslo ˇradku ´ __LINE__ ´ C99: jmeno funkce __func__ ´ ım makra NDEBUG lze vypnout definovan´ #define NDEBUG #include IJC — Jazyk C

120/252


a c e f l m s t

Pˇr´ıklad

//#define NDEBUG #include double logarithm(const double x) { assert( x > 0.0 ); /* zde plat´ ı podm´ ınka */ .... }

IJC — Jazyk C

121/252


a c e f l m s t

ctype.h – makra pro klasifikaci znaku˚ int int int int int int int int int int int int int

isalnum(int c) isalpha(int c) iscntrl(int c) isdigit(int c) isgraph(int c) islower(int c) isprint(int c) ispunct(int c) isspace(int c) isupper(int c) isxdigit(int c) toupper(int c) tolower(int c)

p´ısmeno nebo cˇ ´ıslice [A-Za-z0-9] p´ısmeno [A-Za-z] ˇr´ıdic´ı znak cˇ ´ıslice [0-9] tisknutelný znak bez mezery male´ p´ısmeno [a-z] tisknutelný znak vˇcetneˇ mezery tisknutelný znak bez alnum a mezery ˇ oddelovaˇ c velke´ p´ısmeno [A-Z] ´ sˇ estnactkov a´ cˇ ´ıslice [0-9A-Fa-f] pˇrevod znaku na velke´ p´ısmeno pˇrevod znaku na male´ p´ısmeno

´ Poznamky: Rozsah parametru: unsigned char + EOF Makra vrac´ı hodnoty ==0 a !=0 (NE 0 nebo 1) IJC — Jazyk C

122/252


a c e f l m s t

´ errno.h – chybove´ kody int errno ´ ı (pseudo)promenn ˇ a´ nastavovana´ std. funkcemi, je globaln´ ´ na zaˇcatku programu je nulova´ ´ Norma definuje pouze zakladn´ ı hodnoty: EDOM EILSEQ ERANGE

´ domenov a´ chyba C99: chyba konverze na wchar_t pˇreteˇcen´ı nebo podteˇcen´ı

ˇ implementace pak podle OS doplnuje dalˇs´ı ´ Poznamka: perror()

IJC — Jazyk C

123/252


a c e f l m s t

float.h – charakteristiky floating-point typu˚

´ ı: FLT_ROUNDS Zaokrouhlovan´ FLT_EVAL_METHOD ´ Zaklad: FLT_RADIX Minimum, maximum a pˇresnost: {FLT|DBL|LDBL} *_MANT_DIG, *_DIG, DECIMAL_DIG, *_MAX, *_MIN, *_EPSILON, *_MIN_EXP, *_MIN_10_EXP, *_MAX_EXP, *_MAX_10_EXP,

IJC — Jazyk C

124/252


a c e f l m s t

limits.h – rozsahy celoˇc´ıselných typu˚

CHAR_BIT = poˇcet bitu˚ typu char MB_LEN_MAX = max poˇcet bajtu˚ v ’xxx’ SCHAR_MIN, SCHAR_MAX, UCHAR_MAX, CHAR_MIN, CHAR_MAX SHRT_MIN, SHRT_MAX, USHRT_MAX INT_MIN, INT_MAX, UINT_MAX LONG_MIN, LONG_MAX, ULONG_MAX C99: LLONG_MIN, LLONG_MAX, ULLONG_MAX

IJC — Jazyk C

125/252


a c e f l m s t

´ locale.h – funkce pro narodn´ ı/jazykovou podporu ´ datum, cˇ as, mena, ˇ Konvence pro formaty: znaky abecedy, ˇrazen´ı ˇretezc ˇ u, ˚ ... ˇ ´ ı standardn´ıch funkc´ı (isalpha(), ...) Ovlivnuje chovan´ Definuje typ struct lconv, makra LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME a funkce char *setlocale(int category, const char *locale); struct lconv *localeconv(void); Po startu programu plat´ı: setlocale(LC_ALL, "C");

IJC — Jazyk C

126/252


a c e f l m s t

math.h – matematicke´ funkce

ˇ zne´ matematicke´ funkce pro double, float Definuje vˇsechny beˇ (pˇr´ıpona f), a long double (pˇr´ıpona l): sin, asin, cos, acos, tan, atan, atan2, ... sqrt, pow, exp, log, log10, ... lgamma, tgamma, ... fabs, fmin, fmax, ... floor, ceil, round, fmod, modf, ... makra INFINITY, isinf(), NAN, isnan(x) ´ Poznamky: C99: complex varianty: csin, csinf, ...

IJC — Jazyk C

127/252


a c e f l m s t

´ ı skoky setjmp.h – nelokaln´ deklarace: int setjmp(jmp_buf jmpb); void longjmp(jmp_buf jmpb, int retval); ´ ı skok setjmp – pˇr´ıprava pro nelokaln´ ´ ı skok longjmp – provede nelokaln´ ´ ı longjmp obnov´ı stav programu tak, jakoby setjmp volan´ ´ skonˇcil s navratovou hodnotou retval. (longjmp nemuˇ ˚ ze ´ pˇr´ıpadeˇ je zmen ˇ ena ˇ pˇredat hodnotu 0 v retval, v takovem na 1.) ´ longjmp muˇ pouze z funkce, ktera´ byla ˚ ze být volano ´ zavolana z funkce, ktera´ volala pˇr´ısluˇsný setjmp. setjmp lze volat jen z vhodných m´ıst a dojde k naruˇsen´ı ˇ ych, ktere´ byly zmen ˇ eny ˇ mezi volan´ ´ ım ne-volatile promenn´ setjmp a longjmp. IJC — Jazyk C

128/252


a c e f l m s t

´ ı skoky setjmp.h – nelokaln´

ˇ setjmp je pouˇzitelne´ pro oˇsetˇren´ı chyb a výjimek (nekdy se ´ ı uloh pouˇz´ıva´ i pro implementaci kooperativn´ıho zpracovan´ ´ - viz ”coroutines”) ´ Navratov e´ hodnoty: ´ Kdyˇz dojde k navratu ´ setjmp vrac´ı 0 kdyˇz je volan. ´ ı longjmp, setjmp vrac´ı nenulovou z setjmp po volan´ hodnotu. longjmp se nikdy nevrac´ı

IJC — Jazyk C

129/252


a c e f l m s t

Pˇr´ıklad pouˇzit´ı setjmp(), longjmp() void subroutine(jmp_buf jmp) longjmp(jmp,1); }

{

int main() { int value; jmp_buf jmp; value = setjmp(jmp); if (value != 0) { printf("Byl vol´ an longjmp(jmp,%d)\n", value); exit(value); } printf("Vol´ an´ ı podprogramu ... \n"); subroutine(jmp); return 0; } IJC — Jazyk C

130/252


a c e f l m s t

´ ı signal ´ u˚ signal.h – zpracovan´ Komunikace procesu, ˚ výjimky void (*signal(int sig, void (*func)(int s)))(int); int raise(int sig); raise signal

´ cˇ ´ıslo sig procesu vyˇsle signal ´ zpracovan ´ urˇcuje jak bude pˇrijatý signal

Definovane´ konstanty: SIG_DFL SIG_ERR SIG_IGN

nastav´ı implicitn´ı obsluhu ´ indikuje chybu pˇri navratu z funkce signal ´ ignoruje signal

Uˇzivatelem specifikovane´ obsluˇzne´ funkce mohou konˇcit ´ ım abort, _exit, exit, nebo longjmp. return nebo volan´ IJC — Jazyk C

131/252


a c e f l m s t

´ u˚ Typy signal SIGABRT SIGFPE SIGILL SIGINT SIGSEGV SIGTERM

´ ı ukonˇcen´ı abnormaln´ ´ ˇ ı nulou) chyba operace v plovouc´ı cˇ arce (delen´ ´ ı operace nelegaln´ ctrl-C ˇ chyba pˇr´ıstupu k pameti poˇzadavek ukonˇcen´ı programu

´ Poznamky: ´ ´ ı pˇri signalu ´ behem ˇ Problemy: nedefinovane´ chovan´ ´ ´ obsluhy jineho signalu ´ nevhodne´ – pouˇz´ıvat POSIX signaly ´ ISO C signaly ´ u˚ UNIX definuje cca 30 typu˚ signal IJC — Jazyk C

132/252


a c e f l m s t

ˇ ym poˇctem argumentu˚ stdarg.h – funkce s promenn´ va_list

typ ukazatele na argumenty

Makra pro pˇrenositelný pˇr´ıstup k argumentum: ˚ void va_start(va_list ap, lastfix); type va_arg(va_list ap, type); void va_end(va_list ap); Makro va_start mus´ı být pouˇzito jako prvn´ı. Nastav´ı ap tak, aby ukazoval na prvn´ı z volitelných argumentu˚ funkce. Napˇr´ıklad: void f(int i, char *lastfix, ...); Jednotlive´ hodnoty argumentu˚ vrac´ı makro va_arg. Druhý parametr type urˇcuje typ argumentu. (Nelze pouˇz´ıt typy char, unsigned char, nebo float.) ´ ı argumentu. Nakonec va_end uzavˇre zpracovan´ ˚ IJC — Jazyk C

133/252


a c e f l m s t

´ Pˇr´ıklad: Souˇcet seznamu cˇ ´ısel ukonˇceneho nulou int sum(int i1, ...) { int total = i1; va_list ap; // ukazatel int arg; va_start(ap, i1); while ((arg = va_arg(ap,int)) != 0) // 0=konec total += arg; va_end(ap); return total; } int main(void) { printf("Souˇ cet = %d\n", sum(1, 2, 3, 4, 0)); return 0; } IJC — Jazyk C

134/252


a c e f l m s t

ˇ stddef.h – nekter a´ makra a datove´ typy ptrdiff_t size_t wchar_t NULL offsetof( typ, ˇ clen ) Pˇr´ıklady:

rozd´ıl ukazatelu˚ velikost objektu˚ ´ znaky (UNICODE) ’ˇsiroke’

struct xx { int a, b; }; size_t off = offsetof( struct xx, b ); size_t sz = sizeof( struct xx ); int p[10]; ptrdiff_t dif = (char*)&p[10] - (char*)&p[0]; wchar_t c = L’H’; IJC — Jazyk C

135/252


a c e f l m s t

stdio.h – standardn´ı vstup/výstup

Typy: size_t FILE fpos_t Makra:

ˇ velikost objektu˚ v pameti soubor pozice v souboru

NULL, EOF FOPEN_MAX, FILENAME_MAX SEEK_CUR, SEEK_END, SEEK_SET ˇ e: ´ Promenn stdin, stdout, stderr

IJC — Jazyk C

136/252


a c e f l m s t

stdio.h – standardn´ı vstup/výstup Funkce: remove, rename, tmpfile fopen, freopen, fread, fwrite, fclose fprintf, fscanf, printf, scanf, sprintf, sscanf vfprintf, vprintf, vsprintf, fgetc, fgets, fputc, fputs, getc, getchar, putc, putchar, puts ungetc, fgetpos, fseek, fsetpos, ftell, rewind clearerr, feof, ferror, perror ´ Poznamka: C99: orientace, mbstate_t, fwide(), getwchar(), wprintf(), ... IJC — Jazyk C

137/252


a c e f l m s t

funkce getchar, putchar int getchar(void); cˇ te jeden znak stdin. Naraz´ı-li na konec souboru, vrac´ı hodnotu EOF. Ekvivalent getc(stdin). int putchar(char c); zapisuje jeden znak do stdout. Nelze-li zapsat, vrac´ı EOF, jinak vrac´ı c. Ekvivalent putc(c,stdout). Pˇr´ıklad: konverze na mala´ p´ısmena (filtr) #include <stdio.h> #include int main() { int c; while((c=getchar())!=EOF) putchar(tolower(c)); } IJC — Jazyk C

138/252


a c e f l m s t

Funkce fgets char *fgets(char *s, int size, FILE *stream); ´ ˇ snem ´ cˇ ten´ı, NULL cˇ te ˇradek ze souboru stream. Vrac´ı s pˇri usp ´ eˇ pˇri EOF. Znak ’\n’ pˇreˇcte a uloˇz´ı do s (na rozd´ıl od gets). Funkce gets uˇz nen´ı v ISO C11 char *gets(char *s); ´ Nepouˇz´ıvat – nekontroluje delku vstupu! Funkce puts int puts(const char *s); ˇ ´ zap´ısˇ e ˇretezec do stdout a pˇrejde na nový ˇradek (na rozd´ıl od ˇ jinak vrac´ı nezapornou ´ fputs). Vrac´ı EOF pˇri chybe, hodnotu. IJC — Jazyk C

139/252


a c e f l m s t

´ Funkce printf – formatovan´ y výstup do stdout int printf(const char *fmt, ...); ˇ ´ tisku fmt: ˇretezec obsahuj´ıc´ı format % d o x u c s e f g

-

IJC — Jazyk C

prefix form´ atu des´ ıtkovˇ e cel´ e ˇ c´ ıslo oktalovˇ e cel´ e ˇ c´ ıslo sestn´ ˇ actkovˇ e cel´ e ˇ c´ ıslo des´ ıtkovˇ e bez znam´ enka znak retˇ ˇ ezec pohybliv´ a ˇ c´ arka s exponentem pohybliv´ a ˇ c´ arka bez exponentu kratˇ s´ ı z %e nebo %f 140/252


a c e f l m s t

Funkce printf – pˇr´ıklady

%5.2lf %10s %-10s %10.5s %.10s % d %#g %06x

IJC — Jazyk C

´ long float 5 m´ıst, 2 desetinna, ´ min. delka 10 ´ ı doleva zarovnan´ ´ delka 10, tiskne pouze 5 znaku, ˚ zleva mezery ˇ tisk ˇretezce, je-li delˇs´ı max. 10 znaku˚ ´ ´ znamenko ’-’ nebo ’ ’ na zaˇcatku cˇ ´ısla vˇzdy desetinna´ teˇcka, ponecha´ koncove´ nuly ponecha´ uvodn´ ı nuly: -00001 ´

141/252


a c e f l m s t

´ Funkce scanf – formatovan´ y vstup ze stdin int scanf(const char *fmt, ...); ˇ sneˇ naˇctených format ´ u˚ podle specifikace: vrac´ı poˇcet usp ´ eˇ znaky ’ ’, ’\t’, ’\n’ se ignoruj´ı jine´ znaky se mus´ı shodovat se vstupn´ım textem ´ % – prefix formatu * – potlaˇc´ı pˇriˇrazen´ı volitelneˇ sˇ ´ıˇrka pole ´ vstup format argument d, ld des´ıtkove´ cˇ ´ıslo int*, long* o, lo osmiˇckove´ cˇ ´ıslo int*, long* ´ x, lx sˇ estnactkov e´ cˇ ´ıslo int*, long* h short short* c jediný znak char* ˇretezec ˇ s char[], char* ´ e´ cˇ ´ıslo f, lf realn float*, double* IJC — Jazyk C

142/252


a c e f l m s t

Funkce scanf – pˇr´ıklady

int i; float x; char name[50]; scanf("%2d %f %*d %2s", &i, &x, name); /* & */ Vstup: 56789 0123 45a72 Výsledek: i = 56; x = 789.0; name = "45"

IJC — Jazyk C

143/252


a c e f l m s t

Funkce *printf *scanf fprintf, fscanf – tisk a cˇ ten´ı ze souboru int fprintf(FILE *f, const char *fmt, ...); int fscanf(FILE *f, const char *fmt, ...); ´ e´ konverze v pameti ˇ sprintf, sscanf – formatov int sprintf(char *s, const char *fmt, ...); int sscanf(const char *s, const char *fmt, ...); ´ Poznamky: ´ zajiˇst’uje programator ´ konzistenci parametru˚ a formatu scanf vyˇzaduje ukazatele jako parametry ´ ı pameti ˇ scanf, sprintf — nebezpeˇc´ı pˇrepsan´ implicitn´ı konverze/rozˇs´ıˇren´ı argumentu˚ IJC — Jazyk C

144/252


a c e f l m s t

Pˇr´ıklad: int i; char c; scanf(" %d ", i ); scanf(" %d ", &c );

IJC — Jazyk C

/* pozor - chyba! */ /* pozor - chyba! */

145/252


a c e f l m s t

´ se soubory Prace Funkce fopen – otevˇren´ı souboru FILE *fopen(const char *name, const char *mode); ´ name je jmeno souboru, mode je reˇzim otevˇren´ı: ´ ıho souboru "r" "rb" cˇ ten´ı, cˇ ten´ı binarn´ ´ "w" "wb" zapis ´ an´ ´ ı na konec "a" "ab" pˇridav ´ Poznamka: kombinace "r+", "w+b", "rb+" atd... Pˇri chybeˇ vrac´ı NULL Pˇr´ıklad: const char *name = "test.txt"; FILE *fp = fopen( name, "r" ); if( fp == NULL ) error("soubor %s nelze otevˇ r´ ıt pro ˇ cten´ ı", name); IJC — Jazyk C

146/252


a c e f l m s t

funkce fclose – uzavˇren´ı souboru int fclose(FILE *f); Vrac´ı EOF v pˇr´ıpadeˇ chyby, jinak nulu

IJC — Jazyk C

147/252


a c e f l m s t

ˇ Pˇr´ıklad: zˇretezen´ ı souboru˚ na stdout (cat)

IJC

void filecopy(FILE *fp); int main(int argc, char *argv[]) { FILE *fp; if( argc==1 ) filecopy(stdin); else while( --argc > 0 ) if( (fp=fopen(*++argv,"r")) == NULL ) { printf("cat: can’t open %s \n", *argv); continue; /* dalˇ s´ ı soubor */ } else { filecopy(fp); fclose(fp); } return 0; — Jazyk } C

148/252


a c e f l m s t

Pˇr´ıklad: cat – dokonˇcen´ı

void filecopy(FILE *fp) { /* neefektivn´ ı */ int c; while( (c=getc(fp)) != EOF ) putc( c, stdout ); }

IJC — Jazyk C

149/252


a c e f l m s t

stdlib.h – obecneˇ pouˇzitelne´ funkce div_t, ldiv_t EXIT_FAILURE, EXIT_SUCCESS RAND_MAX MB_CUR_MAX Funkce:

typy pro div, ldiv parametry exit() maximum rand() max. poˇcet bajtu˚ v ’xxx’

abs, div, labs, ldiv bsearch, qsort, rand, srand atof, atoi, atol, strtod, strtol, strtoul mblen, mbstowcs, mbtowc, wcstombs, wctomb calloc, free, malloc, realloc abort, atexit, exit, getenv, system

IJC — Jazyk C

150/252


a c e f l m s t

ˇ Pˇrevod ˇretezce na cˇ ´ıslo

double atof( const char * s); int atoi( const char * s ); long atol( const char * s ); double strtod( const char *s, char **endptr); long strtol( const char *s, char **endptr, int base); unsigned long strtoul(const char *s, char **e, int b); ˇ endptr – ukazatel do ˇretezce po konverzi (nen´ı-li NULL) ´ base – zaklad cˇ ´ıselne´ soustavy

IJC — Jazyk C

151/252


a c e f l m s t

Funkce atexit ´ ı zadaných funkc´ı na konci programu Volan´ int atexit( void (*func)(void) ); ´ ı pˇred skonˇcen´ım programu registruje funkci pro zavolan´ (poˇrad´ı LIFO) dovoluje registraci min. 32 funkc´ı ˇ vrac´ı nulu v pˇr´ıpadeˇ usp ´ echu ´ ı chyb funkce exit – zpracovan´ void exit(int e); ´ ´ ukonˇc´ı program s navratov´ ym kodem e

IJC — Jazyk C

152/252


a c e f l m s t

Funkce atexit – pˇr´ıklad #include <stdio.h> #include <stdlib.h> FILE *fp; void Close(void) { fputs("\nEXIT\n",fp); fclose(fp); } int main(int argc, char *argv[]) { // test argc ... if( (fp=fopen(argv[1],"w")) == NULL ) { fprintf(stderr, "can’t open %s \n", argv[1]); exit(1); // ukonˇ cen´ ı s chybou } atexit(Close); DoSomething(fp); // m˚ uˇ ze volat exit() return 0; // ukonˇ cen´ ı bez chyby - n´ asleduje exit(0); } IJC — Jazyk C

153/252


a c e f l m s t

ˇ an´ ´ ı pameti ˇ Dynamicke´ pˇridelov

void void void void

*malloc(size_t size); *realloc(void *ptr, size_t size); *calloc(size_t memb, size_t size); free(void *ptr);

malloc free calloc realloc

IJC — Jazyk C

ˇ ı pamet ˇ ’ o zadane´ velikosti pˇridel´ ˇ ˇ’ uvoln´ı pˇridelenou pamet ˇ ı a nuluje pamet ˇ’ pˇridel´ ˇ s´ı/zmenˇs´ı pˇridelenou ˇ ˇ ’ (muˇ zvetˇ pamet ˚ ze pˇresunout)

154/252


a c e f l m s t

Pˇr´ıklad: malloc a free #include <stdlib.h> typedef struct prvek { int data; struct prvek *dalsi; } prvek; prvek *novy_prvek(void) { prvek *p = malloc(sizeof(prvek)); if( p == NULL ) /* pozor! mus´ ı se testovat! */ error("chyba: m´ alo pamˇ eti"); return p; } void zrus_prvek(prvek *ptr) free(ptr); } IJC — Jazyk C

{

155/252


a c e f l m s t

´ s ˇretezci ˇ ˇı string.h – prace a pamet´ strlen strcpy strncpy strcat strncat strcmp strncmp strcoll strchr strrchr strstr

´ ˇretezce ˇ delka ˇ kopie ˇretezce ˇ kopie ˇretezce (max. n znaku) ˚ ˇ pˇripojen´ı ˇretezce ˇ pˇripojen´ı ˇretezce (max. n znaku) ˚ ´ ı dvou ˇretezc ˇ u˚ porovnan´ ´ ı dvou ˇretezc ˇ u˚ (max. n znaku) porovnan´ ˚ ´ ´ porovnan´ı podle narodn´ı abecedy (LC_COLLATE) ´ ı znaku vyhledan´ ´ ı znaku od konce vyhledan´ ´ ı podˇretezce ˇ vyhledan´

size_t, NULL

IJC — Jazyk C

156/252


a c e f l m s t

´ s pamet´ ˇı Prace ˇ memcpy kopie bloku˚ pameti ˇ memmove kopie pˇrekrývaj´ıc´ıch se bloku˚ pameti ´ ı bloku˚ pameti ˇ memcmp porovnan´ ´ ı bajtu memchr vyhledan´ memset nastaven´ı bajtu˚ ... ˇ Poˇcet bajtu˚ je dalˇs´ım parametrem techto funkc´ı. Pˇr´ıklad: void f(void) { int pole[SIZE]; int pole2[SIZE]; memset(pole, 0, SIZE * sizeof(pole[0]) ); memcpy(pole2, pole, sizeof(pole2) ); } IJC — Jazyk C

157/252


a c e f l m s t

´ s cˇ asovými udaji time.h – prace ´ CLOCKS_PER_SEC clock_t time_t struct tm funkce: clock difftime mktime time

poˇcet tiku˚ za sekundu ´ systemov´ y cˇ as [tiky] cˇ as [s] tm_sec, tm_mday, ...

´ cˇ as od zaˇcatku programu [tiky] rozd´ıl cˇ asu˚ v sec pˇrevod na intern´ı reprezentaci cˇ asu souˇcasna´ hodnota cˇ asu [s]

asctime, ctime, gmtime, localtime, strftime

IJC — Jazyk C

158/252


a c e f l m s t

´ s cˇ asovými udaji Pˇr´ıklad: Prace ´

struct tm t; t.tm_year = 1995 - 1900; t.tm_mon = 10 - 1; t.tm_mday = 6; t.tm_hour = 12; t.tm_min = 0; t.tm_sec = 1; t.tm_isdst = -1; if( mktime(&t) != -1 ) if(t.tm_wday == 5) puts("p´ atek");

IJC — Jazyk C

/* rok /* mˇ es´ ıc /* den

od 1900 */ 0..11 */ 1..31 */

/* letn´ ı ˇ cas? */ /* OK */

159/252


Jazyk Knihovny

ISO-C99 Nove´ vlastnosti jazyka C podle normy C99: typ long long a souvisej´ıc´ı funkce negeneruje implicitn´ı prototypy funkc´ı inline funkce (§6.7.4) ˇ Nekdy inline definice vyˇzaduje dalˇs´ı extern deklaraci v ´ modulu a nen´ı specifikovano, ´ jedinem zda se funkce ´ rozvine nebo zavola. Pozor na stare´ verze GCC (4.3+ a -std=c99 je O.K.) inline int plus1(int a, int b) { return a+b; } inline int plus2(int a, int b) { return a+b; } int main(void) { // pouˇ zijte gcc -stdc=c99 return plus1(1,2)+plus2(3,4); // chyba bez -O2 } IJC — Jazyk C

160/252


Jazyk Knihovny

´ (typ) { inicializace } Strukturovane´ literaly: ˇ u˚ (pouze ve Automaticka´ pole nekonstantn´ıch rozmer funkc´ıch) T f(int n) { int pole[n]; // variable-length array // ... } // n´ asleduj´ ıc´ ı T f(int n, int T f(int n, int T f(int n, int T f(int n, int

prototypy jsou ekvivalentn´ ı: m, int a[n][m]); m, int a[*][*]); m, int a[ ][*]); m, int a[ ][m]);

(viz ISO C99 §6.7.5.3) IJC — Jazyk C

161/252


Jazyk Knihovny

pole na konci struktury (flexible array member) struct S { int n; T array[]; }; Typ _Bool a makra v <stdbool.h> (konstanty true, false a typ bool). ´ typy Komplexn´ı cˇ ´ısla. V jsou definovany complex, imaginary a cela´ ˇrada funkc´ı. Napˇr´ıklad: double complex cacos(double complex z); float complex cacosf(float complex z); long double complex cacosl(long double complex z); jsou definice funkce acos.

IJC — Jazyk C

162/252


Jazyk Knihovny

restrict ukazatel je jedinou pˇr´ıstupovou cestou k objektu. ´ Vhodne´ pro lepˇs´ı optimalizaci; kvalifikator restrict lze ˇ významu. kdykoli vynechat bez zmeny Pˇr´ıklad: void f (char * restrict s1, const char * restrict s2, int n) { while(n--) *s1++ = *s2++; }

void g1 (int p[restrict][32]); void g2 (int (* restrict p)[32]);

IJC — Jazyk C

163/252


Jazyk Knihovny

Nove´ funkce: snprintf, vscanf ´ ´ Identifikator jmena funkce: __func__ ´ \uXXXX \UXXXXXXXX Znakove´ literaly ˇ ym poˇctem argumentu˚ makra s promenn´ #define debug(...) #define showlist(...)

fprintf(stderr, __VA_ARGS__) puts(#__VA_ARGS__)

standardn´ı #pragma definice #pragma STDC co jak co := {FP_CONTRACT|FENV_ACCESS|CX_LIMITED_RANGE} jak := {ON|OFF|DEFAULT} ´ pragma operator #define M

IJC — Jazyk C

_Pragma(string-literal) // v makrech

164/252


Jazyk Knihovny

Standardn´ı knihovny C99 soubor complex.h fenv.h

inttypes.h

stdbool.h stdint.h

tgmath.h IJC — Jazyk C

co obsahuje podpora pro komplexn´ı cˇ ´ısla nastaven´ı parametru˚ prostˇred´ı pro výpoˇcty ´ ´ ı, zprav plovouc´ı cˇ arce (reˇzim zaokrouhlovan´ ´ ı výjimek) covan´ rozˇs´ıˇren´ı definic celoˇc´ıselných typu˚ v stdint.h ´ o makra pro formaty pro printf a deklarace funkc´ı strtoimax, strtoumax, wcstoimax a wcstoumax podpora typu bool celoˇc´ıselne´ typy – napˇr´ıklad intmax_t, uintmax_t, int8_t, uint8_t, int_least32_t, int_fast32_t, atd. typoveˇ genericka´ makra 165/252


Jazyk Knihovny

´ ı Standardn´ı knihovny C99 – pokraˇcovan´

soubor iso646.h wchar.h

wctype.h

IJC — Jazyk C

co obsahuje AMD1: podpora omezených znakových sad (and == && atd.) AMD1: podpora wchar_t, definuje napˇr´ıklad funkce: fwprintf, swprintf, wcstol, wcscpy, wcsmemcpy, atd. AMD1: ctype.h pro typ wchar_t — definuje typy a funkce iswdigit atd.

166/252


Jazyk Knihovny

Genericka´ makra v <math.h> genericke´ funkce funkce makro acos cacos acos asin casin asin atan catan atan cos ccos cos sin csin sin tan ctan tan exp cexp exp log clog log pow cpow pow sqrt csqrt sqrt fabs cabs fabs ... ... ...

IJC — Jazyk C

167/252


´ ´ ı Pˇrehled Techniky Nastroje Testovan´

ˇ ı programu˚ Laden´ ´ ı mame ´ Pˇri programovan´ dveˇ moˇznosti: ´ programy bez chyb psat ˇ nebo se nauˇcit hledat a odstranovat chyby v programech (debugging) ˇ ı je cˇ asoveˇ naroˇ ´ cne´ laden´ je tˇreba se uˇcit z vlastn´ıch i ciz´ıch chyb ´ vliv pouˇziteho programovac´ıho jazyka

Prevence chyb Techniky pro omezen´ı chyb: ´ dobrý navrh programu (rozhran´ı, ...) dobrý styl psan´ı programu˚ ´ ı okrajových podm´ınek, assert(), ... dukladn e´ testovan´ ˚ ´ ıch dat omezen´ı globaln´ ´ ı nastroj ´ ´ pouˇz´ıvan´ u˚ pro kontrolu spravnosti programu˚ (lint, valgrind, electric fence, ...) ´ ´ Poznamka: Pozor na chyby zpusoben e´ nepochopen´ım kodu ˚ IJC — Jazyk C

168/252



Ladic´ı program (debugger) ´ ˇ ı stavu interaktivn´ı nastroj vhodný pro zjiˇsten´ moˇznosti ladic´ıch programu: ˚ ´ ı programu krokovan´ ˇ registru, výpis obsahu pameti, ˚ ... ´ výpis stavu zasobn´ ıku (stack-trace) ˇ y, HW) breakpoint (podm´ınen´ ˇ y, HW) watchpoint (podm´ınen´ ´ ˇ ´ automaticke spuˇsten´ı pˇri výskytu problemu ˇ post-mortem laden´ı: core ˇ z´ıc´ımu procesu pˇripojen´ı k jiˇz beˇ ´ e´ laden´ ˇ ı vzdalen ...

ˇ nejsou vˇzdy dostupne´ (embedded, nekter e´ jazyky, ...) ´ ´ ´ problemy: paraleln´ı procesy/vlakna, operaˇcn´ı systemy, ´ distribuovane´ systemy ´ er: ˇ ne vˇzdy vhodne´ Zav IJC — Jazyk C

169/252



ˇ ı programu˚ Techniky laden´ Pouˇzit´ı ladic´ıch programu. ˚ ´ Výpisy (log-file) a jejich analýza (výhody: souˇcast ˇ ˇ s´ı). programu, lze zapnout/vypnout, nekdy efektivnejˇ ´ ı moˇznych ˇ chyb – doporucen´ ˇ ı Zkouman´ ´ pˇr´ıcin jednoduˇssˇ ´ı pˇr´ıpady: ´ ı obvyklých chyb: chybej´ ˇ ıc´ı & v scanf, chybne´ hledan´ ´ printf/scanf, a podobne´ (nastroje: ´ formaty gcc -Wall, program lint, ...) ˇ kodu ´ soustˇredit se na posledn´ı zmeny neopakovat stejne´ chyby, opravit vˇsechny výskyty chyby ´ ˇ ı na pozdejˇ ˇ s´ı dobu (pˇr´ıklad: Mars neodkladat laden´ Pathfinder – reset) sledovat ”stack-trace”– hodnoty parametru˚ funkc´ı ˇ unahlen ´ nedelat e´ opravy ˇ ´ ˇ ´ vysvetlit svuj jinemu (i kdyˇz tomu nerozum´ı) ˚ kod nekomu IJC — Jazyk C

170/252



ˇ s´ı pˇr´ıpady: sloˇzitejˇ zajistit reprodukovatelnost chyby sledovat cˇ etnost výskytu˚ chyby (napˇr´ıklad kaˇzdých X ´ +-1 – prohledat kod ´ na znaku˚ je chyba – asi problem výskyt konstant v okol´ı hodnoty X) kontroln´ı výpisy (log-file), grep ´ ı nastroj ´ pouˇz´ıvan´ u: ˚ grep, diff, awk, ... ´ ´ pˇridavat testy do kodu vizualizace výstupu˚ programu (graf) ´ ret testovac´ı pˇr´ıpady; redukce kodu ´ vytvaˇ s chybou na minimum ´ ˇ laden´ ˇ ı v pˇr´ıpadeˇ dlouhotrvaj´ıc´ıch zaznamenavat prub ˚ eh ´ u˚ problem

IJC — Jazyk C

171/252



ˇ s´ı pˇr´ıpady: nejsloˇzitejˇ ´ zkontrolovat lehce pˇrehlednuteln e´ chyby if (a & 1 == 0) { /* <<<< priorita */ /* nikdy se neprovede ... */ } switch (x) { /* ... */ defaut: /* <<<< pˇ reklep */ /* nikdy se neprovede ... */ } memset(p, n, 0); /* <<<< chybn´ e poˇ rad´ ı argument˚ u */ DPRINTF(("v´ ypis %d\n", i++)); /* <<<< co aˇ z zmiz´ ı? */ nehledat chyby, ktere´ nejsou (vzniknou napˇr´ıklad chybným ´ ım) testovan´ ˇ an´ ´ ı zdroju˚ (memory leaks, file desc.) zkontrolovat uvolnov ´ velmi zˇr´ıdka muˇ OS, ˚ ze být chyba v pˇrekladaˇci, knihovnach, HW (Pˇr´ıklad: isprint(getchar()) a dvoj´ı vyhodnocen´ı) IJC — Jazyk C

172/252



Nereprodukovatelne´ chyby ˇ ych zkontrolovat inicializaci promenn´ ´ ı testovac´ıho kodu ´ pokud po pˇridan´ chyba zmiz´ı – moˇzna´ ˇ (i printf muˇ ˇ’ a chyba alokace pameti ˚ ze alokovat pamet ˇ chovan´ ´ ı) zpusobit zmenu ˚ ´ vypada´ spravn ´ eˇ – nejak ˇ a´ jina´ cˇ ast ´ programu kdyˇz kod ’ ˇ (neinicializovaný ukazatel, vracen´ ´ pˇrepisuje pamet ı odkazu ´ ı promennou, ˇ na lokaln´ pouˇzit´ı dynamicky alokovane´ ˇ po jej´ım uvolnen´ ˇ ı, dvakrat ´ free, ...) pameti ´ ´ ı malloc/free – knihovny (dmalloc, Nastroje: specialn´ efence, ...), program valgrind, ... ´ ı na prostˇred´ı: chyba v programu zavis´ ˇ ych prostˇred´ı (napˇr. LANG), kontrola nastaven´ı promenn´ ´ ´ pˇr´ıstupova´ prava, konfigurace systemu, ... (Pˇr´ıklad: MSDOS: ctrlZ je EOF — nefunguje stdin s bin. daty) IJC — Jazyk C

173/252



ˇ ı ciz´ıho kodu ´ Laden´ ´ Je chyba opravdu v ciz´ım kodu? ´ Nen´ı chyba uˇz znama nebo opravena v nove´ verzi? (bugzilla, ...) ´ ı pˇr´ıklad chyby a nahlasit ´ Vytvoˇrit minimaln´

IJC — Jazyk C

174/252



´ ˇ ı Nastroje pro laden´ debuggery: GDB, DDD, Insight, ... výpisy informac´ı o cˇ innosti procesu: ´ ´ strace, ptrace komunikace s jadrem systemu ´ ı funkc´ı sd´ılených knihoven ltrace volan´ ps, top stav procesu ´ ´ script zaznam výstupu˚ na terminal lsof výpis otevˇrených souboru˚ fuser procesy pracuj´ıc´ı se souborem výpisy informac´ı o programu: ´ nm symboly v modulech/knihovnach ´ size velikost kodu, dat, ... ldd ktere´ dyn. knihovny jsou pouˇzity ˇ strings textove´ ˇretezce v bin. souboru ´ od, hexdump obsah souboru (ruzn ˚ e´ formaty) objdump obsah modulu/programu (disassembly,...) ´ pomocne´ textove´ nastroje: grep, cut, sort, diff, cmp, comm IJC — Jazyk C

175/252



´ ı programu˚ Testovan´

´ ı chyby testovaneho ´ Systematicke´ pokusy o vyvolan´ programu. ˇ ım, ale nen´ı to toteˇ ´ z. Souvis´ı s laden´ ´ Muˇ jejich ˚ ze odhalit chyby, ale nemuˇ ˚ ze dokazat nepˇr´ıtomnost.

IJC — Jazyk C

176/252



´ ı v prub ˇ Testovan´ ˚ ehu psan´ı programu testujte mezn´ı pˇr´ıpady: vstup odpov´ıdaj´ıc´ı velikosti pole +-1 ´ prazdn´ y vstup obrovský vstup ´ ı znaky na vstupu specialn´

´ testujte pre- a post-conditions: zaporn e´ hodnoty nebo nula ´ a´ kladne´ cˇ ´ıslo (pˇr´ıklad USS Yorktown: tam, kde se oˇcekav ˇ ı nulou) delen´ ´ ı — testovat i ”pˇr´ıpady ktere´ nikdy defenzivn´ı programovan´ nenastanou” ´ testujte navratov e´ hodnoty funkc´ı (malloc, fopen, ...)

IJC — Jazyk C

177/252



´ ı Systematicke´ testovan´ ´ v prub ˇ testujte kod implementace ˚ ehu ´ ˇ ´ testujte jednoduche casti jako prvn´ı ´ jaký výstup lze oˇcekavat ´ je tˇreba znat, ˇ rujte invariantn´ı vlastnosti (poˇcty zpracovaných oveˇ ´ zaznam u, ˚ kontroln´ı souˇcty, ...) ´ porovnejte nezavisl e´ implementace stejných algoritmu˚ ˇ rte, zda testujete vˇsechny varianty kodu ´ oveˇ Automatizace testu˚ ´ ı s pˇredchoz´ı verz´ı automaticke´ regresn´ı testy – porovnan´ ´ ´ nezavisl e´ testy – obsahuj´ı vstupy a oˇcekavan e´ výstupy ... ´ Poznamka: ”unit testing”, ”code coverage analysis” IJC — Jazyk C

178/252



´ ı Tipy pro testovan´ vˇzdy testujte sve´ programy ´ tak, aby se oveˇ ˇ rilo oˇsetˇren´ı chyb (specialn´ ´ ı upravte kod ´ ˇ vracej´ıc´ı chybu, zmenˇsen´ı velikost´ı pol´ı, ...) alokator pameti ˇ e´ specialn´ ´ ımi hodnotami inicializujte pole a promenn testujte v ruzn´ ˚ ych prostˇred´ıch (jiný OS, pˇrekladaˇc, HW) ˇ regulaci mnoˇzstv´ı testovac´ıch výpisu˚ umoˇznete (--verbose) ´ ım vypnete ˇ testovac´ı kod ´ (#define NDEBUG) pˇred odevzdan´

IJC — Jazyk C

179/252


´ Uvod do C++ Historie C C with classes ISO C ISO C++ ISO C ISO C++ ISO C ISO C++

(1973) (1981) (1990) (1998) (1999) (2011) (2011) (2014)

K&R = Kerninghan, Ritchie Bjarne Stroustrup, Bell Labs ´ mezinarodn´ ı norma jazyka C (C90) ´ mezinarodn´ ı norma C++ (C++98) norma jazyka C (C99) nova´ verze normy C++ (C++11) nova´ norma jazyka C (C11) aktualizace normy C++ (C++14)

Puvodn´ ı definic´ı je kniha Stroustrup: The C++ Programming ˚ Language (Addison-Wesley 1985, 1991, 1997, 2013). ´ e: ˇ C++14). Plat´ı norma ISO/IEC 14882:2014 (neformaln ´ Poznamka: Pˇrekladaˇce a vývojova´ prostˇred´ı pro jazyk C++ viz WWW. IJC — Jazyk C

180/252


Charakteristika jazyka C++ ˇ Obecneˇ vyuˇzitelný programovac´ı jazyk vyˇssˇ ´ı urovn e. ´ Je standardizovaný (ISO/ANSI) ´ ren´ı knihoven. Podporuje abstraktn´ı datove´ typy a vytvaˇ ´ ˇ a´ kompatibilita) Nastupce jazyka C (zpetn Efektivita ˇ cnost) Objektova´ orientace (tˇr´ıdy, dediˇ ˇ zovat operatory ´ Moˇznost pˇreteˇ Genericke´ tˇr´ıdy a funkce (ˇsablony) Obsluha výjimek Mnoho ruzn´ ˚ ych implementac´ı pˇrekladaˇcu˚ Mnoˇzstv´ı prostˇredku˚ pro ruzn ˚ e´ aplikace (GUI, ...)

IJC — Jazyk C

181/252


Nevýhody C++

ˇ s´ı a sloˇzitejˇ ˇ s´ı neˇz C Je podstatneˇ vetˇ Nen´ı cˇ isteˇ objektoveˇ orientovaný (napˇr. typ int nen´ı tˇr´ıda a ˇ dedit) ˇ nelze z nej ˇ nekter ˇ ´ ´ ı pol´ı se Zdedil e´ problemy jazyka C (indexovan´ ´ ı sprava ´ pameti, ˇ ...) nekontroluje, manualn´ Nen´ı zcela kompatibiln´ı s jazykem C ˇ Ne vˇsechny pˇrekladaˇce dostateˇcneˇ vyhovuj´ı norme. ´ Poznamka: Citace z Internetu: ”There are only two kinds of programming languages: those people always bitch about and those nobody uses.”

IJC — Jazyk C

182/252


Pˇr´ıklady – pˇreklad a sestaven´ı programu Soubor ahoj.cc: #include int main() { std::cout << " Ahoj! \n"; }

// tisk ˇ retˇ ezce

´ ı (UNIX, pˇrekladaˇc GNU C++): Zpusob zpracovan´ ˚ g++ -o ahoj ahoj.cc ./ahoj

# pˇ reklad, sestaven´ ı # spuˇ stˇ en´ ı

´ Poznamka: Pˇr´ıpony .cc, .cpp, .C, .c++, .cxx ˇ ı (UNIX, GNU C++): Optimalizace a laden´ g++ -O2 -o prog prog.cc g++ -g -o prog prog.cc gdb prog IJC — Jazyk C

# +optimalizace # +ladic´ ı informace # ladˇ en´ ı 183/252


ˇ Pˇr´ıklad: cˇ ten´ı a tisk C++ ˇretezce

#include #include <string>

// std::string

int main() { using namespace std; // === nemus´ ıme ps´ at std:: cout << "C++ string" << endl; string s; cout << "s = " << s << endl; cout << "string s (libovoln´ a d´ elka): " << flush; cin >> s ; // sledujte jak funguje (ˇ cte slova) cout << "s = " << s << endl; }

IJC — Jazyk C

184/252


ˇ ´ Pˇr´ıklad: cˇ ten´ı a tisk C ˇretezce v C++ (nevhodne) ˇI ´VAT] // hroz´ ı chyba typu "buffer overflow" [NEPOUZ #include #include <string> using namespace std;

// nemus´ ıme ps´ at std::

int main() { cout << "C string" << endl; char s[100] = ""; cout << "s = " << s << endl; cout << "string s (max 99 zn): " << flush; cin >> s ; // ˇ cte slovo, pozor na "buffer overflow" cout << "s = " << s << endl; } IJC — Jazyk C

185/252


Pˇr´ıklad: cˇ etnost slov // g++ -std=c++11 (nebo c++0x) #include #include <string> #include <map> // kontejner std::map int main() { std::string word; std::map<std::string,int> m; // asociativn´ ı pole while( std::cin >> word ) // ˇ cte slova m[word]++; for(auto x: m) // iterace a tisk std::cout << x.first <<"\t"<< x.second <<"\n"; }

IJC — Jazyk C

186/252


Pˇr´ıklad: cˇ etnost slov (nemodern´ı, C++98) #include #include <string> #include <map>

// kontejner std::map

typedef std::map<std::string,int> typedef map_t::iterator

map_t; mapiter_t;

int main() { std::string word; map_t m; // asociativn´ ı pole while( std::cin >> word ) // ˇ cte slova m[word]++; for(mapiter_t i=m.begin(); i!=m.end(); ++i) // tisk std::cout << i->first <<"\t"<< i->second <<"\n"; } IJC — Jazyk C

187/252


Pˇr´ıklad: ˇrazen´ı cˇ ´ısel, iterator // g++ -std=c++11 #include #include #include #include

// // // //

cout vector sort, copy ostream_iterator

int main() { using namespace std; vector v{4, 2, 5, 1, 3}; // inicializace sort(begin(v), end(v)); // ˇ razen´ ı ostream_iterator o(cout,"\n"); // iter´ ator copy(begin(v), end(v), o); // tisk }

IJC — Jazyk C

188/252


Pˇr´ıklad: ˇrazen´ı cˇ ´ısel (nemodern´ı, C++98) #include // cout #include // vector #include // sort, copy #include // ostream_iterator typedef std::vector vec_t; typedef std::ostream_iterator outiter_t; int main() { const int SIZE = 5; static int a[SIZE] = { 4, 2, 5, 1, 3 }; vec_t v(SIZE); // vektor std::copy(a, a+SIZE, v.begin() ); // kopie std::sort(v.begin(), v.end()); // ˇ razen´ ı outiter_t o(std::cout, "\n"); // iter´ ator std::copy(v.begin(), v.end(), o); // tisk } IJC — Jazyk C

189/252


Pˇr´ıklad: ˇrazen´ı cˇ ´ısel — varianta 2 #include #include #include #include

// // // //

vector sort, copy cout ostream_iterator

int main() { using namespace std; vector v; int i; while ( cin >> i ) // ˇ cten´ ı ˇ c´ ısel ze vstupu v.push_back(i); // vektor se zvˇ etˇ suje sort(v.begin(), v.end()); // ˇ razen´ ı ostream_iterator o(cout, "\n"); copy(v.begin(), v.end(), o); // tisk } IJC — Jazyk C

190/252


Pˇr´ıklad: lambda funkce // g++ -std=c++11 #include #include #include

// cout // vector // sort, copy, for_each

int main() { using namespace std; vector v{ 4, 2, 5, 1, 3 }; // inicializace sort(v.begin(), v.end(), [](int x, int y){return x>y;}); // ˇ razen´ ı int a = 10; // lok´ aln´ ı objekt for_each(v.begin(),v.end(), [&a](int &x){ x += a++; }); // "closure" for(auto x: v) // tisk cout << x << endl; } IJC — Jazyk C

191/252


Rozd´ıly mezi C a C++

´ ı z jazyka C (C++98 z C90, C++11 z C99) C++ vychaz´ ´ z C++ programy Dobˇre napsane´ C programy jsou teˇ ˇ (s nekolika výjimkami: nova´ kl´ıcˇ ova´ slova, povinne´ ˇ s´ı typova´ kontrola, ...) prototypy funkc´ı, silnejˇ ˇ pˇrekladaˇcem kromeˇ Rozd´ıly mezi C a C++ jsou zjiˇsteny ˇ nekolika výjimek: ´ jsou typu char Znakove´ literaly sizeof(’a’) == sizeof(int) // C sizeof(’a’) == sizeof(char) // C++

IJC — Jazyk C

192/252


... Výcˇ tový typ nen´ı ekvivalentn´ı typu int enum e { A }; sizeof(A) == sizeof(int) // C sizeof(A) == sizeof(e) // C++ != sizeof(int) ´ struktury v C++ muˇ ´ objektu, funkce, Jmeno ˚ ze pˇrekrýt jmeno ´ bloku: výcˇ tu nebo typu v nadˇrazenem int x[99]; void f() { struct x { int a; }; sizeof(x); /* pole v C, struktura v C++ */ }

IJC — Jazyk C

193/252


Rozˇs´ıˇren´ı C++ proti C99

typ reference anonymn´ı unie (jsou v C11) ˇ zovan´ ´ ı funkc´ı a operator ´ u˚ pˇreteˇ ´ operatory new, delete, new[] a delete[] tˇr´ıdy (class), abstraktn´ı tˇr´ıdy automaticka´ inicializace (konstruktory, destruktory) zapouzdˇren´ı (private, public, protected) ˇ cnost, nasobn ´ ˇ cnost dediˇ a´ dediˇ ´ ı funkce) polymorfismus (virtualn´ uˇzivatelem definovane´ konverze

IJC — Jazyk C

194/252


´ ı Rozˇs´ıˇren´ı C++ proti C99 – pokraˇcovan´

´ ´ jmeno tˇr´ıdy a výcˇ tu je jmeno typu ukazatele na cˇ leny tˇr´ıd v inicializaci statických objektu˚ je dovolen obecný výraz genericke´ datove´ typy – sˇ ablony (template, typename) obsluha výjimek (try, catch, throw) prostory jmen (namespace, using) ´ ı (static_cast, const_cast, nove´ zpusoby pˇretypovan´ ˚ reinterpret_cast, dynamic_cast) ˇ informace o typu za behu programu (typeid, type_info) kl´ıcˇ ove´ slovo mutable

IJC — Jazyk C

195/252


Novinky v C++11 proti C++98 R-hodnotove´ reference, ”move”konstruktory constexpr ˇ ve specifikaci dat ”POD = Plain Old Data” Zmeny extern template Inicializaˇcn´ı seznamy ´ Sjednocený zapis inicializace (int a{5};) Inference typu˚ (auto,decltype) for cyklus pˇres rozsah kontejneru Lambda funkce a výrazy Alternativn´ı syntaxe funkc´ı []fce(int x)->int{return x;} ´ ı identifikatory ´ Specialn´ override, final nullptr IJC — Jazyk C

196/252


´ ı Novinky v C++11 – pokraˇcovan´ ´ silneˇ typovane´ výcˇ ty Nove, ´ v C++98) template> (problem ´ explicit pro konverzn´ı operatory alias sˇ ablony ˇ ˇ ym poˇctem parametru˚ (”variadic Sablony s promenn´ templates”) ˇ ´ Nove´ ˇretezcov e´ literaly ´ (10kg, 12345bignum) Uˇzivatelem definovane´ literaly ´ Podpora vlaken (thread_local, ...) default a delete konstruktory atd. long long static_assert Moˇznost implementovat ”garbage collector” IJC — Jazyk C

197/252


Novinky v C++14 ˇ a zruˇsen´ı ruzn´ Male´ zmeny ˚ ych omezen´ı: auto f() { .... return x; } auto parametry lambda funkc´ı ˇ ych sˇ ablony promenn´ C99 inicializace { .field=value, .... } ´ ı literaly ´ binarn´ 0b0110 ˇ ´ oddelovaˇ ce v numerických literalech 10’000’000 vylepˇsen´ı a rozˇs´ırˇen´ı std knihovny ... ´ Poznamka: Pˇrekladaˇce a podpora C++14

IJC — Jazyk C

198/252


C++ ´ Poznamky /* text pozn´ amky */ // text pozn´ amky plat´ ı aˇ z do konce ˇ r´ adku ´ Vyhrazene´ identifikatory vˇse co obsahuje dvojite´ podtrˇzen´ı __ na libovolne´ pozici ´ vˇse co zaˇc´ına´ podtrˇzen´ım _ nasledovan´ ym velkým p´ısmenem ´ ı symboly zaˇc´ınaj´ıc´ı podtrˇzen´ım _ globaln´ ´ ı identifikatory ´ Specialn´ v C++11 override final IJC — Jazyk C

199/252


Kl´ıcˇ ova´ slova C++ alignas * alignof * and and_eq asm auto bitand bitor bool break case catch char char16_t * char32_t * class compl const const_cast constexpr * continue IJC — Jazyk C

decltype * default delete do double dynamic_cast else enum explicit export extern false float for friend goto if inline int long mutable

namespace new noexcept * not not_eq nullptr * operator or or_eq private protected public register reinterpret_cast return short signed sizeof static static_assert * static_cast

struct switch template this thread_local* throw true try typedef typeid typename union unsigned using virtual void volatile wchar_t while xor xor_eq 200/252


Alternativn´ı reprezentace <% { and %> } bitand <: [ compl :> ] not_eq %: # or_eq %:%: ## xor_eq

&& & ~ != |= ^=

and_eq bitor not or xor

&= | ! || ^

´ Poznamka: Digraphs (<:) ´ Poznamka: Trigraphs (??/)

(bude zruˇseno v C++17)

// Provede se n´ asleduj´ ıc´ ı pˇ r´ ıkaz??/ i++;

IJC — Jazyk C

201/252


´ Literaly ´ u˚ je stejna´ jako v C. Syntaxe cˇ ´ıselných literal ´ (operator "") C++11: uˇzivatelem definovane´ literaly Pˇr´ıklad: BigNumber operator "" _big(const char * literal_string); BigNumber some_variable = 12345_big; ´ jsou typu: Znakove´ literaly char v C++ int

v C, v C++ pouze v´ıceznakove´ (mbc)

´ Poznamka: V C++ existuj´ı 3 ruzn ˚ e´ znakove´ typy: char, unsigned char a signed char IJC — Jazyk C

202/252


Typova´ kontrola ˇ s´ı neˇz v C: Je v C++ silnejˇ Deklarace: void (*funptr)(); je ukazatel na fci vracej´ıc´ı void v C, ukazatel na fci vracej´ıc´ı void bez parametru˚ v C++ Ukazatel na konstantn´ı objekt nelze pˇriˇradit do ukazatele na nekonstantn´ı objekt. ´ ı programu rozliˇs´ı funkce s Typova´ kontrola pˇri sestavovan´ ruzn´ ˚ ymi parametry Výcˇ tove´ typy: ´ lze pˇriˇradit pouze konstantu daneho typu lze vynechat kl´ıcˇ ove´ slovo enum pˇri pouˇzit´ı ´ ´ ı na hodnotach ´ prvku˚ sizeof výcˇ toveho typu zavis´ IJC — Jazyk C

203/252


´ Poznamky

ˇ e´ cyklu ve for Rozsah deklarace promenn for(int i=1; i<10; i++) { // zde plat´ ı i } Je chybou, kdyˇz je pˇr´ıkazem skoku pˇreskoˇcena inicializace ˇ e´ (pˇrekladaˇc to kontroluje). promenn Pozor na setjmp a longjmp

IJC — Jazyk C

204/252


Typ reference Definice: T & x = Lhodnota_typu_T; Bl´ızke´ ukazatelum ˚ (ale neexistuje obdoba NULL) ´ an´ ´ ı parametru˚ odkazem Pouˇzitelne´ pro pˇredav Nelze vytvoˇrit: referenci na referenci (napˇr. T & & r), ´ je dovoleno, ale jen nepˇr´ımo Pozor: v sˇ ablonach referenci na bitova´ pole, ukazatele na reference, pole referenc´ı.

Výhodou referenc´ı je jednoduchost pouˇzit´ı (na rozd´ıl od *ptr) ´ Poznamka: R-hodnotove´ reference Typ && IJC — Jazyk C

(C++11) 205/252


Typ reference – pˇr´ıklady double x = 1.23456; double & xref = x; // Typick´ e pouˇ zit´ ı double & yref; extern int & zref;

// CHYBA! chyb´ ı inicializace // extern m˚ uˇ ze b´ yt bez inicializace

// Pˇ red´ an´ ı parametru odkazem: void Transpose(Matrix & m); // Vracen´ ı reference: int & f(param); // Pozor na to _co_ se vrac´ ı! f(p) = 1;

IJC — Jazyk C

// Vol´ an´ ı funkce

206/252


Reference — chybna´ nebo netypicka´ pouˇzit´ı const int & i = 7; // Vytvoˇ r´ ı pomocnou promˇ ennou int & i = 7; // CHYBA! nelze pro nekonst. referenci float f = 3.14; const int & ir = f; // pomocn´ a_promˇ enn´ a = 3 ir = 5; // CHYBA! konstantu nelze zmˇ enit ´ Poznamka: Proˇc nelze pouˇz´ıt R-hodnotu s nekonstantn´ı referenc´ı: void incr( int& refint ) { refint++; } void g() { // pozor - toto nen´ ı C++ double d = 1; incr(d); // z´ aludn´ a chyba: nezmˇ en´ ı d ! } IJC — Jazyk C

207/252


Typ bool ´ Booleovske´ literaly: false a true Implicitn´ı konverze bool ---> int true ---> 1 false ---> 0 Konverze cˇ ´ısel, výcˇ tu˚ a ukazatelu˚ na bool 0 ---> false jinak ---> true Výsledek relaˇcn´ı operace je typu bool Pˇr´ıklad: bool test = false; test = (a > b); // bool test = 5; // int ---> bool IJC — Jazyk C

208/252


´ Operatory C++ podle priority ´ operatory ( ) [ ] -> :: . ! ~ + - ++ -- & * (Typ) sizeof new delete .* ->* * / % + << >> < <= > >= == != & ^ | && || ?: = *= /= %= += -= &= ^= |= <<= >>= , IJC — Jazyk C

asociativita → ← → → → → → → → → → → → ← ← → 209/252


´ Operatory C++ ´ operator :: .* ->* new delete static_cast, reinterpret_cast, const_cast, dynamic_cast

IJC — Jazyk C

popis ´ kvalifikator dereference ukazatele na cˇ len tˇr´ıdy pˇres objekt dereference ukazatele na cˇ len tˇr´ıdy pˇres ukazatel na objekt dynamicke´ vytvoˇren´ı objektu zruˇsen´ı objektu ´ ´ ı nove´ operatory pˇretypovan´

210/252


´ Operatory — pˇr´ıklady // alokace pamˇ eti oper´ atorem new: T *p = new T[10*n]; // dynamick´ a alokace pole T *p2 = new T(5); // dynamick´ a alokace objektu // uvolnˇ en´ ı pamˇ eti oper´ atorem delete: delete [] p; // uvolnˇ en´ ı pamˇ eti pole delete p2; // uvolnˇ en´ ı pamˇ eti objektu // alokace a ruˇ sen´ ı pole bajt˚ u: char *s = new char[100]; delete [] s; // char *s2 = static_cast(std::malloc(100)); // std::free(s2);

IJC — Jazyk C

211/252


´ Operator :: ´ ı promenn ˇ e: ´ Pˇr´ıstup ke globaln´ double x; void f() { int x; // lok´ aln´ ı x ::x = 3.1415926; // glob´ aln´ ı x } Explicitn´ı specifikace tˇr´ıdy: class T { public: int metoda(); // deklarace metody }; int T::metoda() { } // definice mimo tˇ r´ ıdu Specifikace prostoru jmen: prostor::identifik´ ator std::cin prostor::podprostor::identifik´ ator IJC — Jazyk C

212/252


Standardn´ı konverze v C++ ´ pˇri Implicitn´ı konverze prob´ıhaj´ı automaticky (jsou-li nutne) ´ ı binarn´ ´ ıch operac´ı: vyhodnocovan´ Kaˇzdý ’malý’ celoˇc´ıselný typ se konvertuje takto: typ konverze na metoda char int podle nastaven´ı unsigned char int dopln´ı nuly ´ signed char int rozˇs´ıˇr´ı znamenko short int stejna´ hodnota unsigned short unsigned int stejna´ hodnota enum int stejna´ hodnota bool int 0 nebo 1 Potom je kaˇzda´ hodnota operandu bud’ int (vˇcetneˇ long a ´ u) unsigned modifikator ˚ double, float nebo long double.

IJC — Jazyk C

213/252


´ ı Standardn´ı konverze v C++ — pokraˇcovan´

1

ˇ ´ Je-li nekter´ y operand long double, je druhý konvertovan na long double

2

Jinak, je-li operand double, konvertuje druhý na double

3

Jinak, je-li operand float, konvertuje druhý na float

4

Jinak, je-li operand unsigned long, konvertuje druhý na unsigned long

5

Jinak, je-li operand long, konvertuje druhý na long

6

Jinak, je-li operand unsigned, konvertuje druhý na unsigned

7

Jinak, jsou oba operandy typu int

Výsledek odpov´ıda´ typu obou operandu˚ po konverzi.

IJC — Jazyk C

214/252


Konverze — pˇr´ıklady

´ Poznamka: ´ an´ ´ ı cˇ ´ısla int s cˇ ´ıslem unsigned muˇ Pˇri porovnav ˚ ze doj´ıt k (pro ˇ ´ ´ um: nekoho neoˇcekavan´ ym) problem ˚ int i = -1; unsigned u = 1234; if(i
IJC — Jazyk C

// sledujte varov´ an´ ı pˇ rekladaˇ ce // nevytiskne nic!

215/252


Explicitn´ı konverze ´ ı programator ´ Explicitn´ı konverze uvad´ do textu programu ˇ (a pˇreb´ıra´ za neˇ veˇskerou odpovednost): (typ) v´ yraz typ(v´ yraz) static_cast(v´ yraz) Pˇr´ıklady:

´ ı Explicitn´ı pˇretypovan´

double(int1)/int2 complex(3.14) int(’c’) static_cast(ptr) reinterpret_cast(ptr)

IJC — Jazyk C

216/252


extern "C" Moˇznost pouˇzit´ı funkc´ı z knihoven jazyka C, pˇr´ıpadneˇ jiných jazyku˚ (ASM, FORTRAN): extern "C" int f(int); extern "C" { int g(int); int h(int); }

´ Poznamky: Prostory jmen (namespace) ´ Makro __cplusplus definovano pˇrekladaˇcem IJC — Jazyk C

217/252


Preprocesor ´ ı Je stejný jako v ISO C, je vhodne´ minimalizovat jeho pouˇz´ıvan´ ´ (protoˇze mame lepˇs´ı prostˇredky): lze nahradit za:

#define K1 10 const int K1 = 10; #define f(x)

(v´ yraz_x)

ˇ sinou nahradit za: lze vetˇ

inline int f(int x) { return v´ yraz_x; } pˇr´ıpadneˇ lze pouˇz´ıt genericke´ funkce: template inline T f(T x) { return v´ yraz_x; }

IJC — Jazyk C

218/252


´ ı programu˚ Knihovny a sestavovan´ ´ Zakladn´ ı koncepty knihovna = mnoˇzina pˇreloˇzených modulu˚ v jednom souboru (pˇr´ıpony: *.a, *.lib, *.so, *.dll) ´ ı) modul object file = pˇreloˇzený (binarn´ (pˇr´ıpony: *.o, *.obj) ´ ı programu = vytvoˇren´ı spustitelneho ´ sestavovan´ souboru spojen´ım modulu˚ a knihoven (program vola´ funkce ˇ z knihoven/jiných modulu˚ a ty mus´ı být dostupne´ nejpozdeji ´ ı) v okamˇziku volan´ Typy sestaven´ı: ´ ren´ı programu staticke´ – pˇri vytvaˇ ˇ ı programu dynamicke´ – pˇri/po spuˇsten´ ´ Poznamky: relokace, Position Independent Code (PIC), linker, loader IJC — Jazyk C

219/252


´ souboru˚ Formaty

COFF, PE (Windows), ELF (POSIX), ... Typicka´ struktura souboru: hlaviˇcka – typ, obsah ´ sekce .text - kod sekce .rodata - konstanty sekce .data - inicializovana´ data, sekce .debug* - ladic´ı informace sekce .rel* - relokaˇcn´ı informace sekce .plt - tabulka pro dyn. sestaven´ı ...

´ Poznamka: Výpis obsahu souboru: ˚ programy objdump, nm, readelf

IJC — Jazyk C

220/252


´ ren´ı statických knihoven Vytvaˇ

´ modulu˚ a index pro Staticke´ knihovny obsahuj´ı kod ´ ı zrychlen´ı sestavovan´ ´ rej´ı se specialn´ ´ ım programem (librarian). POSIX Vytvaˇ ´ r. pouˇz´ıva´ program ar – archivaˇ 1

2

3

IJC — Jazyk C

pˇreklad modulu: ˚ cc -c moduly.c vytvoˇren´ı knihovny: ar parametry knihovna.a moduly.o ´ Pozor – parametry jsou duleˇ ˚ zite! vytvoˇren´ı indexu: ranlib knihovna.a

221/252


´ ren´ı sd´ılených knihoven Vytvaˇ

´ modulu˚ a tabulky odkazu˚ obsahuj´ı kod ´ rej´ı se pˇrekladaˇcem, vytvaˇ 1 2

cc -c -fPIC moduly.c cc -shared -fPIC moduly.o -o knihovna.so

maj´ı pˇr´ıponu .so (shared object) nebo .DLL (Dynamically Linked Library) ´ nezavisl´ ´ ˇ ı v pamet ˇ ’ovem ´ mus´ı obsahovat kod y na um´ısten´ prostoru (PIC) ´ ı funkc´ı pˇres PLT (Procedure Linkage Table) ELF: volan´ ´ Poznamka: libtool

IJC — Jazyk C

222/252


´ ı programu Sestavovan´

pˇrekladaˇc (compiler): ´ vloˇz´ı do pˇreloˇzeneho modulu informace potˇrebne´ pro sestaven´ı (exportovane´ symboly, nedefinovane´ symboly, relokaˇcn´ı informace, ...)

sestavovac´ı program (linker): ´ modulu˚ do adresoveho ´ ˇ um´ıst´ı kod prostoru (nekdy je nutna´ relokace), pˇrep´ısˇ e odkazy skuteˇcnými adresami funkc´ı (pokryt´ı odkazu) ˚

ˇ c (loader): zavadeˇ ˇ ı programu zajist´ı jeho naˇcten´ı do pameti ˇ pˇri spuˇsten´ a pˇr´ıpadne´ dynamicke´ sestaven´ı

IJC — Jazyk C

223/252


Staticke´ sestaven´ı

´ vˇsech funkc´ı výsledný program obsahuje kod typicky se sestavuj´ı cele´ moduly z knihoven Sestavovac´ı programy: gcc -static (implicitneˇ sestavuje dyn.) ld (POSIX), tlink (BC), ...

Výhody: ´ ´ (jeden soubor) nezavislost programu na knihovnach

Nevýhody: ˇ s´ı spustitelne´ soubory, vetˇ ´ knihoven nelze sd´ılet kod

IJC — Jazyk C

224/252


prog.c

m1.c

m2.c

m3.c

m4.c

prog.o

m1.o

m2.o

m3.o

m4.o

cc −c

ar

crt1.o

libc.a

libtest.a

ld

program

IJC — Jazyk C

225/252


Dynamicke´ sestaven´ı

´ funkc´ı, program neobsahuje kod ˇ ı programu k sestaven´ı dojde aˇz po spuˇsten´ ld.so = dynamic linker/loader Výhody: ´ moˇznost nezavisl e´ aktualizace knihoven, menˇs´ı programy, ´ sd´ılen´ı kodu knihoven

Nevýhody: pomalejˇs´ı start procesu, ´ zavislost programu na dalˇs´ıch souborech ´ zavislost na verz´ıch knihoven

IJC — Jazyk C

226/252


prog.c

m1.c

m2.c

gcc −c

m3.c

m4.c

gcc −c −fPIC

prog.o

m1.o

m2.o

m3.o

m4.o

gcc −shared

libc.so

libtest.so

ld.so gcc

program

./program

process

IJC — Jazyk C

227/252


Pouˇzit´ı knihoven Pˇr´ıklad: Program s knihovnou libtest.a gcc -o program -static m1.c m2.c -L. -ltest Pˇr´ıklad: Program s knihovnou libtest.so gcc -o program m1.c m2.c -L. -ltest ´ Poznamky: ˇ ı knihoven! Pozor na um´ısten´ Lze kombinovat staticke´ i dynamicke´ Poˇrad´ı argumentu˚ je významne´ (POSIX) cc prog.c library1.a library2.a library1.a (z knihoven se vyb´ıraj´ı jen potˇrebne´ symboly, pˇri cyklických ´ ´ dvakrat) ´ zavislostech mus´ıme knihovnu uvest ´ Problemy: DLL hell, nekompatibilita verz´ı knihoven, ... IJC — Jazyk C

228/252


´ ı Pouˇzit´ı knihoven – pokraˇcovan´ Program ldd(1) – výpis sd´ılených knihoven ˇ ı sd´ılených knihoven v adresaˇ ´ rove´ struktuˇre (/lib, Um´ısten´ /usr/lib, ...) ´ Jmena souboru˚ se sd´ılenými knihovnami: /usr/lib/libJMENO.so.7.8.9 -- real name /usr/lib/libJMENO.so.7 -- so name (symlink) /usr/lib/libJMENO.so -- linker name (symlink) ´ ´ ı: Parametrizace dynamickeho sestavovan´ ´ re, ve kterých jsou hledany ´ LD_LIBRARY_PATH – adresaˇ sd´ılene´ knihovny ˇ LD_PRELOAD – moˇznost nahradit nekter e´ funkce jinými z pˇrednostneˇ sestavených knihoven (dalˇs´ı informace viz man ld.so) ´ ı: /etc/ld.so.cache, ldconfig(8) Zrychlen´ı sestavovan´ IJC — Jazyk C

229/252


Program make ˇreˇs´ı zavislosti ´ ´ ren´ı programu˚ pˇri vytvaˇ ´ a´ provad ´ en´ ˇ ı akc´ı podle zadaných pravidel uspoˇrad ˇ souboru: pouˇzije se cˇ as posledn´ı zmeny ˇ ´ pokud (ˇcas c´ıle < cˇ as nekter eho zdroje), provede akci, ktera´ vytvoˇr´ı nový c´ılový soubor Pˇr´ıklad: Pravidla v souboru Makefile: program: modul1.o modul2.o modul1.o: modul1.c modul2.o: modul2.c ´ Poznamky: GNU make: implicitn´ı pravidla a akce make CFLAGS=-O2 IJC — Jazyk C

230/252


Pˇr´ıklad ˇ ych Pouˇzit´ı promenn´ CFLAGS = -O2 -Wall -std=c99 CXXFLAGS = -g PROGS = program1 program2

# ?=

all: $(PROGS) program1: program1.c $(CC) $(CFLAGS) -o $@ $< program2: program2.c $(CC) $(CFLAGS) -o $@ $< clean: rm -f $(PROGS) ### pozor na

IJC — Jazyk C

231/252


Implementace GNU make, BSD make Alternativy k make Jam, ... ´ ı zavislost´ ´ Automaticke´ generovan´ ı gcc -MM *.cc >depend vloˇzen´ı do Makefile: -include depend ´ ı Makefile Programy pro generovan´ GNU Autoconf ./configure; make; make install CMake qmake – Qt toolkit imake – X Window System IJC — Jazyk C

232/252


Výkonnost programu˚ (performance) ´ ˇ neoptimalizovat Zakladn´ ı pravidlo: radeji ˇ Pravidlo 90 — 10 (nekdy i 98—2) ´ ı kritických m´ıst v programech: Hledan´ ´ ej´ ˇ ıc´ı) Odhad (ˇcasto zavad ˇ ren´ı cˇ asu: Meˇ pˇr´ıkaz time, funkce time(), clock(), instrukce RDTSC, performance counters, ... Pouˇzit´ı programu˚ typu ’profiler’ (gprof, valgrind, ...). ´ ı pamet ˇ ’ove´ naroˇ ´ cnosti (memprof, ...) Zjiˇst’ovan´ ´ Poznamka: Pˇr´ıliˇs mnoho souvislost´ı — cˇ asto pˇripom´ına´ cˇ ernou magii ´ ˇ ı, podsystemu ´ ´ ı pameti ˇ Vliv vyrovnavac´ ıch pamet´ virtualn´ ´ (výpadky stranek, TLB miss), ... IJC — Jazyk C

233/252


ˇ ´ cnost Casov a´ naroˇ Strategie: Pouˇz´ıt lepˇs´ı algoritmy/datove´ struktury Zapnout optimalizace pˇri pˇrekladu (gcc -O3) ´ upravy ´ ı kodu: ´ Provest kritických cˇ ast´ ´ pˇresun invariantu, ˚ vyhodnocen´ı spoleˇcných podvýrazu, ˚ pouˇzit´ı jiných operac´ı(a<<=2), rozvinut´ı cyklu, ˚ uloˇzit cˇ asto potˇrebne´ výsledky (cache), ´ an´ ´ ı vstupu/výstupu, vyrovnav ´ ı alokace malých objektu, specialn´ ˚ pˇredem vypoˇc´ıtane´ hodnoty (tabulky), ´ ı s menˇs´ı pˇresnost´ı, poˇc´ıtan´ zlepˇsen´ı lokality odkazu, ˚ ´ ı do jineho ´ pˇrepsan´ jazyka (asm) ...

´ Poznamka: Neoptimalizujte co nema´ smysl IJC — Jazyk C

234/252


ˇ ’ova´ naroˇ ´ cnost Pamet ˇ ’ova´ naroˇ ´ cnost Souvislost: cˇ asova´ x pamet Strategie: pouˇz´ıvat co nejmenˇs´ı datove´ typy ´ an´ ´ ı, bitfields radeji ˇ nepouˇz´ıvat) (pozor na zarovnav ´ neukladat co lze snadno znovu vypoˇc´ıtat ´ volit vhodne´ datove´ formaty ´ cna) ´ (napˇr. de/komprese muˇ ˚ ze být cˇ asoveˇ naroˇ ˇ ’i a cache velikost pamet ´ Poznamky: lokalita odkazu, ˚ vliv CPU cache ´ rekurze (pˇr´ıklad: Ackerman) problem memory profiler: valgrind/cachegrind, ... IJC — Jazyk C

235/252


Pˇrenositelnost (portability) ´ Pˇrenositelný program lze pˇreloˇzit na v´ıce ruzn´ ˚ ych platformach (napˇr´ıklad UNIX, Linux/x86, Linux/PPC, Windows, MacOS X, ...) obvykle se odhal´ı v´ıce chyb ´ cnejˇ ˇ s´ı na dodrˇzovan´ ´ ı standardu˚ naroˇ ´ ´ nevyuˇz´ıvat speciality platforem, platformoveˇ zavisl´ y kod ´ davat do samostatných modulu˚ pozor na implementac´ı definovane´ vlastnosti prostˇred´ı ´ ı, little/big (velikost int, poˇrad´ı vedlejˇs´ıch efektu, ˚ zarovnan´ endian, bitfields, un/signed char, ...) ´ na výmenu ˇ dat (pozor na CRLF) pouˇz´ıvat textove´ formaty ...

IJC — Jazyk C

236/252


´ ı Pˇrenositelnost – pokraˇcovan´

Pˇrenositelne´ (multiplatform) knihovny – podstatneˇ ˇ ı psan´ı pˇrenositelných programu˚ (pˇr´ıklady: SDL, usnadnuj´ Qt, WxWidgets, ...). ´ Vhodne´ vývojove´ nastroje (GCC, make, ...). ”Cross development”– editace/pˇreklad/sestaven´ı neprob´ıha´ na c´ılove´ platformeˇ (duleˇ ˚ zite´ pˇredevˇs´ım pro ´ ”embedded”systemy). Automaticka´ detekce konfigurace pˇri pˇrekladu – GNU autoconf: configure; make; make install (GNU build system: Automake, Autoconf, Libtool)

IJC — Jazyk C

237/252


Konverzn´ı programy

Programy pro pˇreklad z jiných jazyku˚ do C: p2c – Pascal f2c – Fortran ˇ ˇ y assembler Nekter e´ jazyky pouˇz´ıvaj´ı C jako vysokourov ´ nov´ (pojem ”translator”, pˇr´ıklady: Cfront C++, Modelica) ... ´ Poznamka: + podpurn ˚ e´ knihovny

IJC — Jazyk C

238/252


´ reviz´ı Programy pro spravu Tyto programy (Revision Control, Version Control Systems) ´ ı zmen ˇ pˇri vývoji programu. dovoluj´ı sledovan´ ˚ Pˇr´ıklady: SCCS (Bell-labs, 1980), RCS (198x), ... Klient-server: CVS (1986), Subversion (2000), ... ´ Git, GNU arch, Bazaar, Monotone, ... Distribuovane: Princip: archiv souboru˚ (repository), operace vloˇzen´ı (commit, checkin), ˇ (checkout), operace výberu ´ a´ pouze zmeny ˇ (algoritmus diff), uklad ˇ pˇr´ıstup k libovolne´ verzi v historii zmen, ˇ moˇznost vetven´ ı (branching), ´ ru. je moˇzný souˇcasný pˇr´ıstup v´ıce vývojaˇ ˚ IJC — Jazyk C

239/252


Subversion Jednoduchý uvod (soubory, ne client-server): ´ svnadmin create svnrep

## zaloˇ zen´ ı repozit´ aˇ re

svn mkdir file:///home/xjmeno99/svnrep/projekt cd /home/xjmeno99/cesta/projekt svn import file:///home/xjmeno99/svnrep/projekt svn checkout file:///home/xjmeno99/svnrep ## editujeme soubory v adres´ aˇ ri ’projekt’ svn commit

## zap´ ıˇ se zmˇ eny, ++cislorevize

svn update -r cislorevize

## n´ avrat k zadan´ e revizi

IJC — Jazyk C

240/252


Git ´ ´ velkými projekty (Linux, ...) Distribuovaný system, pouˇz´ıvan ´ ı repozitaˇ ´ r): Jednoduchý uvod (lokaln´ ´ mkdir adresar cd adresar git init

## zaloˇ zen´ ı (pr´ azdn´ eho) repozit´ aˇ re

## editujeme soubory v adres´ aˇ ri a podadres´ aˇ r´ ıch git add . ## pˇ rid´ ame soubory do sledovan´ ych git commit -a ## zap´ ıˇ se zmˇ eny (TODO: -m) git tag -a -m "Brand New Release" 1.0 ## editujeme soubory v adres´ aˇ ri a podadres´ aˇ r´ ıch git checkout 1.0 ## n´ avrat gitk ## GUI pro sledov´ an´ ı reviz´ ı IJC — Jazyk C

241/252


´ ı Git – pokraˇcovan´ ´ y repozitaˇ ´ r): Jednoduchý uvod (vzdalen´ ´ git clone host:/cesta/adresar ## staˇ zen´ ı repozit´ aˇ re cd adresar ## editujeme soubory v adres´ aˇ ri a podadres´ aˇ r´ ıch git add . ## pˇ rid´ ame soubory do sledovan´ ych git commit -a ## zap´ ıˇ se zmˇ eny (TODO: -m) git push ## z´ apis na server ## editujeme soubory v adres´ aˇ ri a podadres´ aˇ r´ ıch git pull

## staˇ zen´ ı aktualizace ## moˇ zn´ e kolize! # a dalˇ sı ´ (rebase,stash,...) viz literatura Obsah souboru˚ je (po commit) uloˇzen na alesponˇ 2 m´ıstech: ´ e´ — repo2-lokaln´ ´ ı — soubory repo1-vzdalen IJC — Jazyk C

242/252


Pˇr´ıklady API

ˇ eˇ vazan´ ´ Jednoduchý pˇr´ıklad: dlist.h – dvojsmern y seznam (+varianty: Linux lists) Knihovny: ´ ı s (tem ´ eˇ ˇ r) libovolnou pˇresnost´ı GMP – poˇc´ıtan´ zlib, libbzip2 – komprese dat libpng, libgd, SDL, OpenGL – grafika libsnd, libvorbis, OpenAL – zvuk GSL, atlas, BLAS, LAPACK – numericke´ výpoˇcty ´ ı výrazy regex – regularn´ ˇ y jazyk Scheme guile – vestaven´

Plug-in, komponenty: CORBA, XPCOM, ...

IJC — Jazyk C

243/252


´ Bezpeˇcnost – zaklady

´ typu ”buffer overflow”(zasobn´ ´ Problem ık, heap, ...) – je nutne´ dobˇre oˇsetˇrit vstupy ´ ”temporary file creation”– pozor na postup Problem ´ ren´ı jmen doˇcasných souboru˚ vytvaˇ ... ... ... Pˇr´ıklady ´ steˇ u SUID programu˚ a serveru˚ Velmi duleˇ ˚ zite´ zvlaˇ

IJC — Jazyk C

244/252


UCS – pˇrehled ISO 10646, Universal Character Set (UCS), 231 , ”Planes” ´ (U+0041) + jmeno ´ kod znaku (”Latin capital letter A”) Rozsah U+0000 – U+00FF odpov´ıda´ ISO 8859-1 (Latin-1) Unicode je kompatibiln´ı s UCS, nav´ıc algoritmy, atd. ´ ´ ı UCS-2, UCS-4, UTF-8, UTF-16, ... Kodov an´ Kombinace znaku˚ (”combining char”, napˇr. rˇ = ˇ r) ´ Urovn eˇ implementace (Level 1-3) ´ Problemy: ´ ´ ı, BOM ruzn an´ ˚ a´ kodov ´ u˚ pro jeden znak: moˇznost v´ıce kod U+00B5 MICRO SIGN = U+03BC GREEK SMALL LETTER MU ´ Poznamky: International Components for Unicode (ICU), Pango, Qt IJC — Jazyk C

245/252


´ UTF-8 – zaklady UTF = ”UCS Transformation Format” UTF-8 (autor: Ken Thompson, kolem 1992) U00000000 U00000080 U00000800 U00010000 U00200000 U04000000

-

U0000007F: U000007FF: U0000FFFF: U001FFFFF: U03FFFFFF: U7FFFFFFF:

0xxxxxxx 110xxxxx 1110xxxx 11110xxx 111110xx 1111110x

10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx*3 10xxxxxx*4 10xxxxxx*5

´ akceptuje pouze minimaln´ ´ ı Z bezpeˇcnostn´ıch duvod u˚ dekoder ˚ nutnou reprezentaci. UNICODE definuje normalizovane´ formy (NFD,NFC,...).

IJC — Jazyk C

246/252


UTF-8 – pouˇzit´ı Poˇzadavky: ´ System: libc + vygenerovana´ lokalizaˇcn´ı data (locale -a) LC_* nastaveno na UTF-8 (locale; locale charmap) ´ Terminal/editor pracuj´ıc´ı s UTF-8 Pouˇzit´ı setlocale(LC_CTYPE, "") ´ ? Pˇrekladaˇc pracuj´ıc´ı s lokalizacemi UTF-8 (literaly) ? wchar_t, mbs, wcs — pˇr´ımo pouˇzitelne´ jen pokud je ´ definovano makro __STDC_ISO_10646__ s hodnotou yyyymmL ´ ı: Moˇznosti zpracovan´ ´ ı i výstup v UTF-8 Vstup, zpracovan´ ´ ı v wchar_t Vstup/výstup UTF-8, zpracovan´ ´ Nastroje: Pouˇzit´ı libc a lokalizace ´ eˇ rychlejˇs´ı) Vlastn´ı implemantace (potencialn IJC — Jazyk C

247/252


UTF-8 – pouˇzit´ı

Konverze: size_t wcstombs(char *dest, const wchar_t *src, size_t n); size_t mbstowcs(wchar_t *dest, const char *src, size_t n); Thread-safe: wcsrtombs, mbsrtowcs ´ ´ ´ ı: Funkce nezavisl e´ na lokalizaci a kodov an´ strcpy strcat strcmp strstr ´ ´ ´ ı: Funkce zavisl e´ na lokalizaci ale ne na kodov an´ strcoll strxfrm

IJC — Jazyk C

248/252


UTF-8 – pouˇzit´ı

´ ˇretezce: ˇ Delka poˇcet bajtu˚ (pro alokaci) ´ potˇrebne) ´ mbstowcs(NULL,s,0) poˇcet znaku˚ (malo poˇcet pozic na displeji (wcwidth,wcswidth) Editace: ´ an´ ´ ı znaku vklad ruˇsen´ı znaku pozice znaku na obrazovce (ˇc´ınske´ zab´ıraj´ı 2 pozice)

IJC — Jazyk C

249/252


UTF-8 – pˇr´ıklady

´ Zakladn´ ı pouˇzit´ı nevyˇzaduje zapnut´ı lokalizace: #include <stdio.h> int main() { printf("Hello, UTF-8 world: ˇ eˇ sˇ cˇ rˇ z´ y´ a´ ı´ e \n"); return 0; }

IJC — Jazyk C

250/252


UTF-8 – pˇr´ıklady Tisk sˇ irokých znaku: ˚ #include <stdio.h> #include int main() { if(!setlocale(LC_CTYPE, "")) { fprintf(stderr, "Nelze nastavit lokalizaci.\n"); return 1; } printf("%ls\n", L"ˇ eˇ sˇ cˇ rˇ z´ y´ a´ ı´ e ¨ o¨ uß"); // reˇ zim char // wprintf(L"ˇ eˇ sˇ cˇ rˇ z´ y´ a´ ı´ e ¨ o¨ uß"); // wchar_t return 0; }

IJC — Jazyk C

251/252


´ er ˇ – poznamky ´ Zav a souvislosti

Free Software, Projekt GNU Licence (GPL, LGPL, BSD, MIT, MPL, Apache, ...) ´ WWW stranka s odkazy ... Co bude u zkouˇsky

IJC — Jazyk C

252/252

252

Recommend Documents