Charakteristika jazyka C

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


´ Uvod


Pravidla Literatura

ˇ 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: ˚

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

Pravidla Literatura

Pravidla

IJC = ´ sky pˇrednaˇ ukoly ´ konzultace hodnocen´ı celkem 100 bodu: ˚

---------|---------|---------|---------|---------| text programu a pozn´ amky (max 50 znak˚ u)

30b 2 ukoly ´ 70b zkouˇska

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

IJC — Jazyk C

ˇ ı. ˇ ´ Nekde budou pouˇzity rameˇ cky pro zvýraznen´

1/252


IJC — Jazyk C


Pravidla Literatura

Zdroje informac´ı

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

...

4/252

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

IJC — Jazyk C

5/252


Novinky v C11


”static assert”

ˇ 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´ı

anonymn´ı struktury a unie ´ funkce bez navratu

Existuje velke´ mnoˇzstv´ı programu˚ napsaných v C ´ ı jistých pravidel Programy jsou pˇrenositelne´ pˇri dodrˇzovan´

likvidace funkce gets

Existuj´ı pˇrekladaˇce na prakticky vˇsechny platformy ´ ı d´ıky operaˇcn´ımu systemu ´ Popularn´ UNIX.

typoveˇ genericke´ výrazy

výluˇcný pˇr´ıstup k souborum ˚ ˇ ı charakteristik pro float/double/... doplnen´

7/252

IJC — Jazyk C

6/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) ...

Je standardizovaný (ISO/ANSI)

volitelna´ podpora pro kontrolu mez´ı a analýzu

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

IJC — Jazyk C

Obecneˇ vyuˇzitelný programovac´ı jazyk tradiˇcneˇ pouˇz´ıvaný ´ ´ ı. pro systemov e´ programovan´

´ an´ ´ ı (”alignment”) moˇznost specifikovat zarovnav ˇ UNICODE znaky a rˇetezce (bylo v revizi 2004)

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


Charakteristika jazyka C

ˇ ´ normy jsou nepovinne´ (”optional”) nekter e´ cˇ asti ´ podpora vlaken (”threads”)


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

Kernighan B., Pike R.: The Practice of Programming, Addison-Wesley, 1999

IJC — Jazyk C

IJC — Jazyk C

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

´ ı, Kopp, 2008 Herout, P.: Uˇcebnice jazyka C, 5. vydan´

man 3 ´ ˇ ´ prostˇred´ı Napov eda v integrovanem

3/252

Historie jazyka C

British Standards Institute: The C Standard: Incorporating Technical Corrigendum 1, Willey, 2003 (c99)

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/

IJC — Jazyk C


Pravidla Literatura

Literatura

Dobra´ literatura


2/252

8/252

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


´ Poznamky:

cc ahoj.c ./a.out

´ an´ ´ ı zdrojových textu˚ (GNU indent) Automaticke´ formatov ´ ı dokumentace ze zdrojových textu˚ Automaticke´ generovan´ programu˚ (napˇr. doxygen).

# pro Linux, UNIX, GNU C

10/252


IJC — Jazyk C

11/252



Funkce printf

IJC — Jazyk C


12/252


Pˇr´ıkaz for

printf("form´ atovac´ ı ˇ retˇ ezec" [, parametry]);

"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[])"

Pˇr´ıklad

´ ´ Zakladn´ ı formaty %f %d %o %x %c %s %%

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

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

´ ı jazyka Knihovn´ı funkce, nen´ı souˇcast´ ´ ˇ Formatovac´ ı ˇretezec popisuje zpusob tisku parametru, ˚ ˚ ´ ı význam – oznaˇcuje zaˇcatek ´ ´ znak % ma´ specialn´ formatu

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

13/252


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

´ Poznamka: Struktura programu v jazyku C

ˇ ezcov ˇ ´ (C11) Ret e´ literaly

\\ \" \t ...

void char short int long long long float double

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

int main(void) { printf("Ahoj!\n"); return 0; } ´ ı Zpusob ˚ zpracovan´



Soubor ahoj.c

´ an´ ´ ı textu programu je duleˇ Zarovnav ˚ zite´ pro jeho dobrou ´ ı nevyˇzaduj´ı ani nekontroluj´ı. cˇ itelnost. Pˇrekladaˇce zarovnan´

ˇ ezce ˇ Ret


´ Zakladn´ ı datove´ typy

#include <stdio.h>

IJC — Jazyk C


Prvn´ı program


Symbolicke´ konstanty

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

ˇ´ 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 %

IJC — Jazyk C


14/252


IJC — Jazyk C


15/252


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

Standardn´ı vstup ˇ ıtan´ ´ ı znaku˚ Pˇr´ıklad: poc´

#define

JMENO

#define

ZACATEK 1

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

hodnota

Pouˇzit´ı const nebo enum

int main(void) { int c; while ( (c = getchar()) != EOF ) putchar(c); return 0; }

Druha´ verze

const int ZACATEK = 1; enum { ZACATEK = 1 };

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

nen´ı zcela ekvivalentn´ı, ale obecneˇ lepˇs´ı.

IJC — Jazyk C

Standardn´ı vstup → standardn´ı výstup #include <stdio.h>

16/252

IJC — Jazyk C

17/252

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


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

´ ı 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 20/252


IJC — Jazyk C

22/252


Jazyk C – systematicka´ definice

IJC — Jazyk C


23/252


& ’ ( )

* . < [ ^ | + / = \ _ } , : > ] { ~ ; ? ´ mezera, nový rˇadek, BS, HT, VT, FF


IJC — Jazyk C


&= ( ) * *=

+ ++ += , -

--= -> . /

/= : ; <

<< <<= <= =

== > >= >>

>>= ? [ ]

^ ^= { |

|= || } ~

C89: ”implementation defined”,

´ Poznamka: ˇ ´ Nekter e´ zastarale´ (ne ISO C) implementace nevkladaly mezeru

25/252

24/252

´ Poznamka: ´ ´ Operator % a zaporn a´ cˇ ´ısla:

´ ISO C nedovoluje vnoˇrene´ poznamky. (Pouˇzijte #if 0 ) ´ ´ Poznamka je pˇrepsana na jednu mezeru aˇz po rozvoji maker

´ ˇ ´ ´ V identifikatorech, znakových/ˇretezcov´ ych literalech, jmenech ´ ach ´ mohou být i jine´ znaky. hlaviˇckových souboru˚ a poznamk


IJC — Jazyk C

! % %= & &&

// text C99+ pozn´ amky do konce ˇ r´ adku // pozn´ amka s trigraph ??/ pokraˇ cuje i na dalˇ s´ ım ˇ r´ adku

graficke´ znaky:


´ ´ Operatory a separatory

/* text C pozn´ amky */

p´ısmena: a-zA-Z cˇ ´ıslice: 0-9

21/252

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

´ Poznamky (comments)

´ Zakladn´ ı mnoˇzina znaku˚ (1 byte)

IJC — Jazyk C

´ ı Pˇr´ıklad: ... pokraˇcovan´

void copy(char s[], const char s1[]) { /* s1 do s */ while( (*s++ = *s1++) != ’\0’ ); }

´ Poznamka: K&R nezna´ pojem prototyp funkce

IJC — Jazyk C



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

#define MAXLINE 1000 /* implementaˇ cn´ ı limit */ int getline(char s[], int lim) { int c, i; for(i=0; i
´ nepouˇz´ıvat) Podle K&R (velmi zastarale,

! " # %

IJC — Jazyk C


Definice funkce

´ Pˇr´ıklad: nalezen´ı nejdelˇs´ıho ˇradku v textu ...

K&R definice funkce



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

19/252



Pˇr´ıklad: histogram poˇctu cˇ ´ıslic

C99, C11: LIA (Language Independent Arithmetic) ´ ´ Poznamka: pro znamenkov´ y typ zbytek 6= modulo 26/252

IJC — Jazyk C

27/252



´ Identifikatory



Kl´ıcˇ ova´ slova

rozliˇsuj´ı se velka´ a mala´ p´ısmena (case sensitive) ´ ı rozliˇsovana´ delka ´ minimaln´ 63(31) znaku˚ ´ ´ u: konvence pro zapis identifikator ˚

auto break case char const continue default do double

´ 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ýcˇ tu˚ (”tags”), cˇ leny struktur/uni´ı a ostatn´ı ´ idetifikatory. IJC — Jazyk C



Typy a velikost udaj ´ u˚

void bool char short int int long int long long int float double long double float complex double complex

switch typedef union unsigned void volatile while

IJC — Jazyk C

29/252


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

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



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.


30/252


pˇr´ıpona bez pˇr´ıpony l nebo L ll nebo LL u nebo U

const T

´ v plovouc´ı ˇradov ´ ´ Literaly e´ cˇ arce

IJC — Jazyk C


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

const a volatile

31/252

ˇ’ 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

ˇ ıselne´ literaly ´ Celoc´

signed char unsigned int

IJC — Jazyk C

0L 077 32/252


typ int long long long +specifikace unsigned

Pˇr´ıklady

´ Poznamka: ”const-correctness” IJC — Jazyk C


´ cela´ cˇ ´ısla Literaly:

unsigned char unsigned unsigned long

Pˇr´ıklady sizeof(T) pro ruzn ˚ e´ architektury PC/64bit 1 2 4 nebo 8 8 8 4 8 16 8

long register restrict return short signed sizeof static struct

signed a unsigned

|char| <= |short| <= |int| <= |long| <= |long long|

char short int long long long float double long double void*

else enum extern float for goto if inline int

_Alignas _Atomic _Complex _Imaginary _Static_assert _Alignof _Bool _Generic _Noreturn _Thread_local

28/252


Jednoduche´ typy a velikost udaj ´ u˚


´ Znakove´ literaly

2999888777UL 0x3F

1234567890123456789LL 0xFFFFU

IJC — Jazyk C

33/252



´ literaly ´ V´ıceznakove´ a ’ˇsiroke’

´ je typu int ’’ znakový literal, pˇr´ıpona bez pˇr´ıpony l nebo L f nebo F

´ ı znaky (”escape-sequence”) Specialn´

typ double long double float

\’ \a \b \f \n \r \t \\ \x<ˇ c´ ıslo> \<ˇ c´ ıslo>

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:

Znakove´ konstanty

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´

anglický term´ın multi-byte character wide character wide character wide character

’n’ 34/252

IJC — Jazyk C

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

Pˇr´ıklady IJC — Jazyk C

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

’\\’

’\n’

’\x80’

’\0’

’\’’ 35/252

IJC — Jazyk C

36/252


ˇ ezcov ˇ ´ Ret e´ literaly




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

datov´ y_typ

´ zapis "" u8"" L"" u"" U""

"\0" "12"

37/252


const char int double

/* ukazatel na funkci */

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

// U"abc"

IJC — Jazyk C

38/252



IJC — Jazyk C

39/252



´ Viditelnost identifikatoru

Rozsah deklarace

´ ı) 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

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

void (*fp)(void);

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

u8"nˇ eco"

Okamˇzik inicializace

Pˇr´ıklad: ´ ´ ı 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

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 }

int x = 10; int main() { double x = 1.1; printf("%f",x); return 0; }

´ jmeno makra ma´ rozsah od pˇr´ıkazu #define do konce textu modulu nebo do pˇr´ıkazu #undef

40/252


IJC — Jazyk C

41/252



´ ren´ı nových jmen (synonym) datových typu. Vytvaˇ ˚ ´ Nejde o vytvoˇren´ı noveho typu.

Deklarace/definice ukazatele

Pˇr´ıklady

´ ı ukazatele na objekt (promennou) ˇ Z´ıskan´


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

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

px = &x; y = *px; // v tomto kontextu ekvivalent y = x

typedef char * string_t; string_t s, lineptr[10];

Výskyt na leve´ straneˇ pˇriˇrazen´ı (pojem L-hodnota)

je ekvivalentn´ı:

*px = 0; *px += 4; (*px)++;

char *s, *lineptr[10]; 43/252

IJC — Jazyk C


´ 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

ˇ Odkaz na objekt (promennou) y = *px;

42/252

Pouˇzit´ı ukazatelu˚

int x, y; px = &x; // oper´ ator z´ ısk´ an´ ı adresy objektu

typedef int (*ptr2f_t)(void); /* ukaz. na funkci */ ptr2f_t numcmp, swap;

/* zde plat´ ı int x */

IJC — Jazyk C

int *px = NULL;

typedef int length_t; length_t len, maxlen=100;

/* ve funkci plat´ ı double x */

void printx(void) { printf("%d",x); }

Ukazatel, adresa

typedef

IJC — Jazyk C

char void

"ˇ retˇ ezec1" <mezery, nov´ e ˇ r´ adky> "ˇ retˇ ezec2" // "ˇ retˇ ezec1ˇ retˇ ezec2"

"a" "b" U"c"


Pˇr´ıklady

" text \ pokraˇ cov´ an´ ı textu na n´ asleduj´ ıc´ ım ˇ r´ adku"

ˇ 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

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

"text se znakem \" v ˇ retˇ ezci"

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

IJC — Jazyk C


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

ˇ ezcov ˇ Ret e´ konstanty



Deklarace

44/252

IJC — Jazyk C

45/252



´ Adresový prostor – obrazek



Ukazatele jako argumenty funkc´ı


int a[10], *pa; pa = &a[0]; // ukazatel na prvn´ ı prvek pole x = *pa; // je ekvivalentn´ ı x = a[0]

´ ´ ena ˇ ˇ ych Pˇr´ıklad: Vzajemn a´ zam hodnot promenn´ void swap(int *px, int *py) { register int temp = *px; *px = *py; *py = temp; }

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´ı:

Vol´ an´ ı: int x,y; /*...*/ swap(&x,&y); ^^^^^ pozor!

a[i] == *(pa+i) a[i] == *(a+i) ´ Poznamky: Nen´ı moˇzne´ zapsat a++ Meze pol´ı se nekontroluj´ı

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

46/252



Adresova´ aritmetika

47/252


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

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

48/252



int strlen(const char *s) { int n; for(n=0; *s!=’\0’; s++) n++; return n; }

´ ˇ posouvat ani Dva ukazatele nelze sˇc´ıtat, nasobit, delit, ˇ hlasit ´ chybu. kombinovat s float a double — pˇrekladaˇc by mel

´ Operace maj´ı smysl jen v ramci jednoho pole. Napˇr´ıklad:

IJC — Jazyk C

´ ˇretezce ˇ Pˇr´ıklad: delka

Omezen´ı operac´ı s ukazateli

´ et ˇ aditivn´ı operace. S ukazateli lze provad ´ Jednotkou výpoˇctu je velikost c´ıloveho objektu.

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

49/252


IJC — Jazyk C



Ukazatel a pole


Pˇrehled povolených operac´ı:

IJC — Jazyk C

50/252


ˇ ezce ˇ Ret


IJC — Jazyk C

51/252


ˇ ezce ˇ ´ ı Ret – pokraˇcovan´


ˇ ezec ˇ Ret je pole znaku, ˚ lze jej tedy ”pˇriˇradit”ukazateli: 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´ı

IJC — Jazyk C

char *strncpy(char *s1, const char*s2, size_t n); ´ ı rˇetezc ˇ u: spojovan´ ˚

ˇ 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´

ˇ ı: 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’;

ˇ u˚ s omezen´ım delky: ´ kopie ˇretezc

char *message = ""; // inicializace message = "Now is the time."; // nejde o kopii!

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

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>

´ 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 52/252

IJC — Jazyk C

53/252

IJC — Jazyk C

54/252



ˇ a´ pole V´ıcerozmern

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.

IJC — Jazyk C


IJC — Jazyk C

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



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

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 58/252


IJC — Jazyk C

59/252



IJC — Jazyk C


60/252


´ ı slov v textu ... Pˇr´ıklad – poˇc´ıtan´

Velikost struktury v bajtech

Neupln ´ a´ deklarace struktury:


Povolene´ operace jsou pouze: ˇ ı poloˇzky . zpˇr´ıstupnen´ = pˇriˇrazen´ı (nebo inicializace) ´ ı ukazatele na promennou ˇ & z´ıskan´

Odkaz na cˇ len struktury:

-i -i hodnota -i=hodnota --include hodnota --include[=hodnota]

57/252

Struktury – omezen´ı

struct Date d = {21,10,1993}; struct Date dat2;

´ argumentu˚ ´ Poznamka: getopt a ruzn ˚ e´ formaty

Struktura muˇ ˚ ze obsahovat ukazatel na sebe:

struct ABC;

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

sizeof(struct XYZ) sizeof(dat1) sizeof dat1 // bez z´ avorek jen pro v´ yrazy

Lze pouˇz´ıt pro definici ukazatelu: ˚ struct ABC *p;

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

ˇ e: ´ Nelze pouˇz´ıt pro definici promenn struct ABC x; /* chyba */ Pouˇzit´ı ukazatele na strukturu struct Date *uk = &d;

´ Poznamky: Little endian / big endian, _Alignof(type-name) _Alignas(type-name) _Alignas(const-expr)

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

IJC — Jazyk C

struct Date { unsigned char day; unsigned char month; int year; };

int main(int argc, char *argv[]) { while(--argc>0) printf("%s ", *++argv); // ˇ spatnˇ e ˇ citeln´ e printf("\n"); return 0; }


´ argv[0] je jmeno programu (nebo ""), argv[argc] ma´ hodnotu NULL

Struktury

Druha´ (horˇs´ı) varianta výpisu argumentu˚

IJC — Jazyk C

TEST argument1 argument2 .... posledn´ ı_argument argv[0] argv[1] argv[2] argv[argc-1]

56/252



ˇ ı: Programu TEST lze zadat argumenty pˇri spuˇsten´

char a[10][20]; // pole znakov´ ych pol´ ı char *b[10]; // pole ukazatel˚ u na ˇ retˇ ezce 55/252


´ ˇradku ´ Argumenty pˇr´ıkazoveho (command line)

´ Poznamka:

parametr typu pole (T[]) je ekvivalentn´ı parametru typu ukazatel (T*)

program program program program program


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

ˇ pole (do libovolne´ urovn ˇ prvkem pole muˇ e) ˚ ze být opet ´



Inicializace pole ukazatelu˚

61/252

IJC — Jazyk C

62/252

IJC — Jazyk C

63/252



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


Nevýhody:

Pˇr´ıklad: struct flags { unsigned is_kw : unsigned is_ext : unsigned : unsigned is_stat : unsigned : unsigned num_bit : } flags; // velikost


´ ´ ı adresy) Nelze pouˇz´ıt operator & (z´ıskan´ ´ Pomalejˇs´ı pˇr´ıstup k poloˇzkam

IJC — Jazyk C

´ Poznamka: Lze nahradit explicitn´ı prac´ı s bitovými operacemi

65/252



´ obsahuje adresu kodu funkce, ´ ı funkce (ukazatelova´ aritmetika muˇ ˚ ze být pouˇzit pouze k volan´ ´ Ukazatel: nen´ı pouˇzitelna).

reprezentuje ukazatel na funkci bez parametru˚ vracej´ıc´ı typ T. ´ Mame-li funkci:

union u_tag { int ival; float fval; char *pval; } u;

potom pˇriˇrazen´ı do ukazatele ma´ v ANSI C tvar:

T funkce(void) { /* k´ od funkce */ }

fp = &funkce;

// & lze vynechat

´ ı funkce: Pouˇzit´ı ukazatele k volan´ (*fp)(); fp(); 67/252


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

IJC — Jazyk C

68/252



Výcˇ tový typ

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

char *lineptr[100]; // pole ˇ retˇ ezc˚ u int nlines; .... sort(lineptr,nlines,&strcmp); ^^^^^^^ probl´ em: konverze

Pˇr´ıklady enum dny { PO, UT, ST, typedef enum Boolean { enum bitmask { bit0=1, bit2=4, enum { RAZ, DVA, TRI }

´ Poznamka: Standardn´ı knihovna obsahuje qsort() 70/252

IJC — Jazyk C


IJC — Jazyk C

69/252



Pˇr´ıklad:

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

kde int strcmp(const char *s1, const char *s2); je standardn´ı funkce z knihovny (viz <string.h>).


Pouˇzit´ı výcˇ tu

Konstanty ve výcˇ tu jsou typu int a maj´ı hodnoty rostouc´ı postupneˇ od nuly Lze explicitneˇ specifikovat hodnoty poloˇzek (konstant)

Pˇr´ıklad: ˇrazen´ı pole ukazatelu˚ – pouˇzit´ı:

66/252

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

T (*fp)(void);

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

Pˇr´ıklad – ˇrazen´ı pole ukazatelu˚ ...

Pˇr´ıklad:

IJC — Jazyk C

´ ı bitu˚ (od LSB nebo od MSB) nen´ı Poˇrad´ı obsazovan´ ´ normou definovano = nepˇrenositelne´

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

Ukazatel na funkci

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



Lze pouˇz´ıt pouze uvnitˇr struktur (a uni´ı)

Unie (1.p union)

IJC — Jazyk C


´ ı Bitova´ pole – pokraˇcovan´

ˇ Vhodne´ pro usporn e´ uloˇzen´ı dat na nekolika bitech ´

64/252



Bitova´ pole (bitfields)

Pˇr´ıklad – ... vloˇzen´ı do stromu

enum dny d=PO; int i = d; d++; printf("%d", d); d = 2;

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

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

71/252

IJC — Jazyk C

72/252



´ Operatory

|| && !

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

´ Relaˇcn´ı operatory == != <

>

<=

>=



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

5

1

IJC — Jazyk C

IJC — Jazyk C

3

74/252




´ ´ ı Operatory – pokraˇcovan´

IJC — Jazyk C

75/252


´ kontextove´ operace delen´ ˇ ı Pˇr´ıklad: problem

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

f = i1/(i2+1.0)

IJC — Jazyk C



(typ) v´ yraz

int i1,i2; double f; ... f = i1/i2; f = (double)i1/i2;

int getchar(void); /* vrac´ ı EOF (tj. -1) nebo znak 0 .. 255 int c; c = getchar(); if(c==EOF) ....

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

Explicitn´ı konverze

Pˇr´ıklad:

76/252


2

– vznika´ pˇri pˇrevodu znaku˚ na int: signed char → int rozsah −128 .. 127 unsigned char → int rozsah 0 .. 255

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

4

´ ıch aritmetických Obvykle´ aritmeticke´ konverze u binarn´ operac´ı:

´ signed/unsigned char Problem

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

3

´ Poznamka: argumenty funkc´ı (...), K&R float → double

(year%4 == 0 && year%100 != 0 || year%400 == 0)

73/252


Celoˇc´ıselna´ rozˇs´ırˇen´ı (integral promotions): ´ ı hodnotu vˇcetneˇ znamenka ´ zachovavaj´ char, short int, bitova´ pole → int nebo unsigned

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

Pˇr´ıklad:

IJC — Jazyk C

2


Implicitn´ı konverze typu˚

´ ´ ı: Zkracen e´ vyhodnocovan´ A || B je-li A!=0, pak se B nevyhodnocuje A && B je-li A==0, pak se B nevyhodnocuje

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

1


´ Logicke´ operatory

´ Aritmeticke´ operatory + * / %



*/

77/252


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

IJC — Jazyk C

78/252




Pˇr´ıklad

´ 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

´ Logicke´ operatory po bitech

´ prefixový zapis ´ postfixový zapis

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

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

& | ^ ~

ˇ ı zadaneho ´ ˇ Pˇr´ıklad: odstranen´ znaku z ˇretezce

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 79/252

IJC — Jazyk C

80/252

IJC — Jazyk C

81/252






Pˇr´ıklad: souˇcet jednotkových bitu˚

´ Pˇriˇrazovac´ı operatory a vyrazy ´ ´ ˇ 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



Pˇr´ıklad

+=

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

-=

*=

/=

%=

<<=

>>=

&=

^=

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

|=

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

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

x = x * (y + 1) ´ Poznamka: Pozor na vedlejˇs´ı efekty

Nen´ı nutne´ optimalizovat spoleˇcne´ podvýrazy, ˇ s´ı: cˇ asto je cˇ itelnejˇ

i = i++; pole[j] = pole[k]++;

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

yyval[yypv[p3+p4]+yypv[p1+p2]] += 2; IJC — Jazyk C


82/252



IJC — Jazyk C

83/252



´ u˚ Priorita a asociativita operator

ˇ 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

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

IJC — Jazyk C

IJC — Jazyk C


84/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´ 86/252

IJC — Jazyk C

87/252

* + & ^ | ´ Uvod ISO C libc C99 Debug C++ Link Opt .


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


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

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

88/252

IJC — Jazyk C




´ ı vyhledav ´ an´ ´ ı Pˇr´ıklad: binarn´

ˇ y´ pˇr´ıkaz Podm´ınen

IJC — Jazyk C


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!

89/252

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



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

Cyklus for for( ; ; ) for(;;)

// nekoneˇ cn´ y cyklus

for(int i=0; i

IJC — Jazyk C

92/252



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

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

IJC — Jazyk C


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


95/252


´ eˇ ˇ st´ı Pˇr´ıkaz goto a nav

´ Poznamky: ˇ minimalizovat pouˇzit´ı Pouˇz´ıvat opatrne, ´ Nikdy neskakat do strukturovaných pˇr´ıkazu˚

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

IJC — Jazyk C

97/252

IJC — Jazyk C


96/252


int f() { for (....) for (....) { // 2. ´ uroveˇ n // .... if (chyba) goto error; // .... } return kladny_vysledek; error: // oˇ setˇ ren´ ı chyby return -1; }

void f() { // .... goto identifik´ ator; // .... identifik´ ator : pˇ r´ ıkaz; // .... }

for( i=0; i= 0 */ }

IJC — Jazyk C

{

Pˇr´ıklad – prakticke´ pouˇzit´ı skoku

´ Pouˇzitelne´ pouze v ramci jedne´ funkce ˇ cyklu a pokraˇcuje podm´ınkou cyklu Pˇreskoˇc´ı zbytek tela


´ ı koncových mezer a tabulator ´ u˚ Pˇr´ıklad: vynechan´ // cykl´ ı dokud podm´ ınka plat´ ı

do { s[i++] = n % 10 + ’0’; }while( (n/=10) > 0 );

Pˇr´ıkaz continue


93/252

Ukonˇcuje nejbl´ızˇ e nadˇrazený pˇr´ıkaz switch, while, for, nebo do-while

´ poˇrad´ı Pˇr´ıklad: konverze cˇ ´ısla na znaky v opaˇcnem

94/252

IJC — Jazyk C

Pˇr´ıkaz break

´ Poznamky: Provede se alesponˇ jednou Podle statistik cca 5% cyklu˚

´ ˇ ıc´ı argumenty funkc´ı nejsou ´ Poznamka: cˇ arky oddeluj´ ´ operatory!


Pˇr´ıklad: ˇrazen´ı vzestupneˇ (shell-sort)

while ( )

91/252



Cyklus while





98/252

IJC — Jazyk C

99/252



Funkce



Rekurze



Argumenty funkc´ı

viz Rekurze.

typ jm´ eno ( deklarace_parametr˚ u ) { deklarace lok´ aln´ ıch promˇ enn´ ych pˇ r´ ıkazy // C99: i deklarace }

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

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

´ 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

´ Poznamky: C99+: inline funkce, C11: _Noreturn IJC — Jazyk C

´ Poznamka: tail recursion 100/252



´ ı Argumenty funkc´ı – pokraˇcovan´

IJC — Jazyk C

101/252



ˇ e´ Extern´ı promenn

IJC — Jazyk C

102/252



Rozsah platnosti

´ ıch promenn´ ˇ ych a funkc´ı Program = mnoˇzina globaln´ ˇ ym ˇ Funkce s promenn ´ poctem argumentu˚

´ ı promenn ˇ e´ Globaln´ ˇ e´ Jsou to staticke´ promenn Inicializace ”pˇri pˇrekladu” (Pouˇzit´ı napˇr. pro omezen´ı poˇctu argumentu˚ funkc´ı)

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´

(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

´ Deklarace funkce je implicitneˇ extern´ı (extern je zbyteˇcne): extern int plus(int,int);

va_list, va_start(), va_arg(), va_end()

int plus(int,int);

ˇ ych je podstatný rozd´ıl: U promenn´

ˇ ym poˇctem argumentu˚ Pˇr´ıklad: Standardn´ı funkce s promenn´

extern int a; int printf(const char *fmt, ... ); int sprintf(char *s, const char *fmt, ... );

int a; // definice

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

IJC — Jazyk C


103/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˚

IJC — Jazyk C


IJC — Jazyk C


IJC — Jazyk C

105/252



ˇ e´ register Promenn ´ jsou uloˇzeny v registru procesoru Pokud je to moˇzne, (rychlost) ˇ e´ Pouze pro automaticke´ promenn

Blokova´ struktura programu ´ urovn ˇ Hierarchie bloku˚ (zanoˇren´ı do ”libovolne” e) ´ ˇ e´ V bloku lze deklarovat promenn

ˇ Nelze z´ıskat ukazatel na registrovou promennou

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

104/252

´ ı deklarace pˇrekrýva´ ostatn´ı (globaln´ ´ ı i lokaln´ ´ ı), plat´ı Lokaln´ ´ ´ ıch parametru˚ to i pro jmena formaln´

Pˇr´ıklad:

// statick´ a a extern´ ı // statick´ a a ne-extern´ ı // statick´ a=ne-extern´ ı

´ Poznamky:

int swap(int *x, int *y) { register int tmp = *x; *x = *y; *y = tmp; }

// statick´ a a lok´ aln´ ı // automatick´ a=lok´ aln´ ı

106/252

IJC — Jazyk C

Nelze vnoˇrovat definice funkc´ı ´ Makra nerespektuj´ı tuto strukturu (nejsou ”hygienicka”)

107/252

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


Pˇr´ıklad:

´ styl – hroz´ı nekonzistence pozor, NEVHODNY

char string1[] = "the"; // pouˇ zit´ ı ˇ retˇ ezce char string2[] = { ’t’, ’h’, ’e’, ’\0’ };

// === modul1.c === // === modul2.c === int x; // definice x extern int x; // deklarace x static int s; static int s;

char nonstring[3] = "the";

void f2(double d);

// nen´ ı ˇ retˇ ezec!

int main() { f2(5); s--; return 0; }

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



Modul je samostatna´ pˇrekladova´ jednotka – soubor *.c

int pole1[] = { 1, 1, 1, 0, 0, }; int pole2[10] = { 1, [5]=0, 1, }; // jen C99+

´ e´ ˇreˇsen´ı Pˇrekladove´ jednotky – spravn


Pˇrekladove´ jednotky (moduly)

Inicializace pol´ı

109/252



ˇ ych Pˇr´ıklady inicializace strukturovaných promenn´

IJC — Jazyk C

Pˇreklad a sestaven´ı v´ıce modulu: ˚ cc modul1.c modul2.c 110/252


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


´ e´ ˇreˇsen´ı 2 Pˇrekladove´ jednotky – spravn

IJC — Jazyk C

111/252



Preprocesor jazyka C Direktivy zaˇc´ınaj´ı znakem # v prvn´ım sloupci

// === rozhrani.h === extern int x; void f2(double d);

ˇ ı 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´ı

// === modul1.c === #include "rozhrani.h" static int s; int x; /* definice */

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

int main() { f2(5); s--; return 0; }

´ Poznamka: Aby to opravdu fungovalo, potˇrebujete ´ eˇ pouˇz´ıt program ”make”nebo podobný. spravn

IJC — Jazyk C

112/252



Vloˇzen´ı souboru s rozhran´ım #include <stdio.h> #include "modul2.h"

// === modul2.c === #include "rozhrani.h" static int s;

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

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

IJC — Jazyk C

Pˇr´ıklad: #define EOF -1 #define NULL ((void*)0) 113/252



ˇ y pˇreklad Podm´ınen´

Makra s parametry

// hled´ a i v ./

IJC — Jazyk C

114/252



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

´ ı usek Vynechan´ u˚ programu ´ Pˇr´ıklad: pozor na priority a vedlejˇs´ı efekty

#ifdef JMENO ..... #endif /* JMENO */

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

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

# ##

´ Pˇr´ıklad: ukazka pouˇzit´ı

#if konstantn´ ı_v´ yraz ..... #elif konstantn´ ı_v´ yraz ..... #else ..... #endif

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

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

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

#define SPOJ(a,b) #define PRINT(x)

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

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

V podm´ınce jsou pouˇzitelne´ pouze konstantn´ı výrazy:

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

defined(linux) && defined(i386) __BORLANDC__ >= 0x0300 IJC — Jazyk C

115/252

IJC — Jazyk C

116/252

IJC — Jazyk C

117/252



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

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

<parametry>

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



a c e f l m s t

/* unsigned char */

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

´ Poznamka: _Pragma IJC — Jazyk C

118/252


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

IJC — Jazyk C

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

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)

121/252

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


IJC — Jazyk C


a c e f l m s t

float.h – charakteristiky floating-point typu˚

´ Norma definuje pouze zakladn´ ı hodnoty: EDOM EILSEQ ERANGE

´ Poznamka: perror()

122/252

IJC — Jazyk C


a c e f l m s t

123/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

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

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,

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

ˇ implementace pak podle OS doplnuje dalˇs´ı

CHAR_BIT = poˇcet bitu˚ typu char MB_LEN_MAX = max poˇcet bajtu˚ v ’xxx’

FLT_EVAL_METHOD ´ Zaklad: FLT_RADIX

a c e f l m s t

int errno ´ ı (pseudo)promenn ˇ a´ nastavovana´ std. funkcemi, je globaln´ ´ na zaˇcatku programu je nulova´

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

´ ı: FLT_ROUNDS Zaokrouhlovan´

120/252

´ errno.h – chybove´ kody

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

IJC — Jazyk C


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

a c e f l m s t

ˇ ı assert.h – Makro pro laden´

Standardn´ı ISO-C knihovny

char *setlocale(int category, const char *locale); struct lconv *localeconv(void);

C99: LLONG_MIN, LLONG_MAX, ULLONG_MAX

Po startu programu plat´ı: setlocale(LC_ALL, "C");

IJC — Jazyk C

124/252

IJC — Jazyk C

125/252

IJC — Jazyk C

126/252



a c e f l m s t

math.h – matematicke´ funkce


a c e f l m s t

´ ı skoky setjmp.h – nelokaln´

a c e f l m s t

´ ı skoky setjmp.h – nelokaln´

deklarace: ˇ 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, ...

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.

makra INFINITY, isinf(), NAN, isnan(x) ´ Poznamky: C99: complex varianty: csin, csinf, ...

IJC — Jazyk C

{

128/252

raise signal

IJC — Jazyk C

129/252


a c e f l m s t

a c e f l m s t

´ u˚ Typy signal

Komunikace procesu, ˚ výjimky

SIGABRT SIGFPE SIGILL SIGINT SIGSEGV SIGTERM

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

´ ı 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

Definovane´ konstanty: SIG_DFL SIG_ERR SIG_IGN

´ Poznamky:

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

´ ´ ı pˇri signalu ´ behem ˇ Problemy: nedefinovane´ chovan´ ´ ´ obsluhy jineho signalu ´ nevhodne´ – pouˇz´ıvat POSIX signaly ´ ISO C signaly

Uˇzivatelem specifikovane´ obsluˇzne´ funkce mohou konˇcit ´ ım abort, _exit, exit, nebo longjmp. return nebo volan´ 130/252

IJC — Jazyk C


a c e f l m s t

ˇ ym poˇctem argumentu˚ stdarg.h – funkce s promenn´ typ ukazatele na argumenty

´ u˚ UNIX definuje cca 30 typu˚ signal 131/252

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

132/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’;

int main(void) { printf("Souˇ cet = %d\n", sum(1, 2, 3, 4, 0)); return 0; } 133/252

IJC — Jazyk C


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

Makra pro pˇrenositelný pˇr´ıstup k argumentum: ˚

IJC — Jazyk C

longjmp se nikdy nevrac´ı

void (*signal(int sig, void (*func)(int s)))(int); int raise(int sig);

IJC — Jazyk C

va_list

´ Kdyˇz dojde k navratu ´ setjmp vrac´ı 0 kdyˇz je volan. ´ ı longjmp, setjmp vrac´ı nenulovou z setjmp po volan´ hodnotu.

´ ı signal ´ u˚ signal.h – zpracovan´

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


a c e f l m s t

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

´ Navratov e´ hodnoty:

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. 127/252


ˇ 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”)

134/252

IJC — Jazyk C

135/252



a c e f l m s t

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


a c e f l m s t

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

a c e f l m s t

funkce getchar, putchar int getchar(void);

Typy: size_t FILE fpos_t Makra:

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

ˇ 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

136/252

IJC — Jazyk C

Pˇr´ıklad: konverze na mala´ p´ısmena (filtr)

137/252


a c e f l m s t

char *fgets(char *s, int size, FILE *stream);

138/252

a c e f l m s t

Funkce printf – pˇr´ıklady

ˇ ´ tisku fmt: ˇretezec obsahuj´ıc´ı format % d o x u c s e f g

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. 139/252

-

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

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

IJC — Jazyk C


a c e f l m s t

´ Funkce scanf – formatovan´ y vstup ze stdin

140/252

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

IJC — Jazyk C

141/252


a c e f l m s t

Funkce scanf – pˇr´ıklady

a c e f l m s t

Funkce *printf *scanf fprintf, fscanf – tisk a cˇ ten´ı ze souboru

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

IJC — Jazyk C

int printf(const char *fmt, ...);

´ ˇ 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).

IJC — Jazyk C

#include <stdio.h> #include int main() { int c; while((c=getchar())!=EOF) putchar(tolower(c)); }


a c e f l m s t

´ Funkce printf – formatovan´ y výstup do stdout

Funkce fgets


int putchar(char c); zapisuje jeden znak do stdout. Nelze-li zapsat, vrac´ı EOF, jinak vrac´ı c. Ekvivalent putc(c,stdout).

´ Poznamka: C99: orientace, mbstate_t, fwide(), getwchar(), wprintf(), ...

IJC — Jazyk C


cˇ te jeden znak stdin. Naraz´ı-li na konec souboru, vrac´ı hodnotu EOF. Ekvivalent getc(stdin).

int fprintf(FILE *f, const char *fmt, ...); int fscanf(FILE *f, const char *fmt, ...); int i; float x; char name[50]; scanf("%2d %f %*d %2s", &i, &x, name); /* & */

´ e´ konverze v pameti ˇ sprintf, sscanf – formatov int sprintf(char *s, const char *fmt, ...); int sscanf(const char *s, const char *fmt, ...);

Vstup: 56789 0123 45a72 Výsledek: i = 56; x = 789.0; name = "45"

´ 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˚

142/252

IJC — Jazyk C

143/252

IJC — Jazyk C

144/252



a c e f l m s t


a c e f l m s t

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

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

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

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

´ 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


145/252

IJC


146/252


a c e f l m s t

ˇ Pˇr´ıklad: zˇretezen´ ı souboru˚ na stdout (cat) 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

IJC — Jazyk C


a c e f l m s t

div_t, ldiv_t EXIT_FAILURE, EXIT_SUCCESS RAND_MAX MB_CUR_MAX Funkce:

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

IJC — Jazyk C

´ ı pˇred skonˇcen´ım programu registruje funkci pro zavolan´ (poˇrad´ı LIFO)

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

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

151/252

IJC — Jazyk C

a c e f l m s t

#include <stdio.h> #include <stdlib.h> FILE *fp; void Close(void) { fputs("\nEXIT\n",fp); fclose(fp); }

int atexit( void (*func)(void) );

ˇ endptr – ukazatel do ˇretezce po konverzi (nen´ı-li NULL) ´ base – zaklad cˇ ´ıselne´ soustavy

150/252

Funkce atexit – pˇr´ıklad

´ ı zadaných funkc´ı na konci programu Volan´

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

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

IJC — Jazyk C


a c e f l m s t

Funkce atexit

double atof( const char * s); int atoi( const char * s ); long atol( const char * s );

a c e f l m s t

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

149/252


a c e f l m s t

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

147/252

stdlib.h – obecneˇ pouˇzitelne´ funkce

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

148/252

IJC — Jazyk C

152/252

IJC — Jazyk C

153/252



a c e f l m s t

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

void void void void

void zrus_prvek(prvek *ptr) free(ptr); } IJC — Jazyk C

154/252


155/252

CLOCKS_PER_SEC clock_t time_t struct tm funkce: clock difftime mktime time

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

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

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;

´ 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]

IJC — Jazyk C

if( mktime(&t) != -1 ) if(t.tm_wday == 5) puts("p´ atek");

158/252


Jazyk Knihovny

156/252

a c e f l m s t

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

asctime, ctime, gmtime, localtime, strftime

157/252

IJC — Jazyk C


a c e f l m s t

´ s cˇ asovými udaji time.h – 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´ı.

´ ˇ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´ ˚ ´ ı podle narodn´ ´ porovnan´ ı abecedy (LC_COLLATE) ´ ı znaku vyhledan´ ´ ı znaku od konce vyhledan´ ´ ı podˇretezce ˇ vyhledan´

size_t, NULL

{

IJC — Jazyk C


a c e f l m s t

´ s pamet´ ˇı Prace


strlen strcpy strncpy strcat strncat strcmp strncmp strcoll strchr strrchr strstr

prvek *novy_prvek(void) { prvek *p = malloc(sizeof(prvek)); if( p == NULL ) /* pozor! mus´ ı se testovat! */ error("chyba: m´ alo pamˇ eti"); return p; }

ˇ ı 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)

a c e f l m s t

´ s ˇretezci ˇ ˇı string.h – prace a pamet´

#include <stdlib.h> typedef struct prvek { int data; struct prvek *dalsi; } prvek;

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

malloc free calloc realloc


a c e f l m s t

Pˇr´ıklad: malloc a free

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

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

IJC — Jazyk C

159/252


Jazyk Knihovny

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

Jazyk Knihovny

ISO-C99 ´ (typ) { inicializace } Strukturovane´ literaly: ˇ u˚ (pouze ve Automaticka´ pole nekonstantn´ıch rozmer funkc´ıch)

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

pole na konci struktury (flexible array member)

T f(int n) { int pole[n]; // variable-length array // ... }

struct S { int n; T array[]; };

// n´ asleduj´ ıc´ ı T f(int n, int T f(int n, int T f(int n, int T f(int n, int

double complex cacos(double complex z); float complex cacosf(float complex z); long double complex cacosl(long double complex z);

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:

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

jsou definice funkce acos.

(viz ISO C99 §6.7.5.3) 160/252

IJC — Jazyk C

161/252

IJC — Jazyk C

162/252



Jazyk Knihovny

Nove´ funkce: snprintf, vscanf ´ ´ Identifikator jmena funkce: __func__

soubor complex.h fenv.h

´ \uXXXX \UXXXXXXXX Znakove´ literaly ˇ ym poˇctem argumentu˚ makra s promenn´

Pˇr´ıklad: void f (char * restrict s1, const char * restrict s2, int n) { while(n--) *s1++ = *s2++; }

#define debug(...) #define showlist(...)

fprintf(stderr, __VA_ARGS__) puts(#__VA_ARGS__)

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

stdbool.h stdint.h

_Pragma(string-literal) // v makrech tgmath.h

163/252

IJC — Jazyk C

164/252


Jazyk Knihovny

wchar.h

wctype.h

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

166/252


IJC — Jazyk C

165/252

´ ´ ı Pˇrehled Techniky Nastroje Testovan´

´ ı 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, ...) 167/252



´ ´ Poznamka: Pozor na chyby zpusoben e´ nepochopen´ım kodu ˚

IJC — Jazyk C



168/252


ˇ ı programu˚ Techniky laden´

Ladic´ı program (debugger)

ˇ s´ı pˇr´ıpady: sloˇzitejˇ

Pouˇzit´ı ladic´ıch programu. ˚ ´ Výpisy (log-file) a jejich analýza (výhody: souˇcast ˇ ˇ s´ı). programu, lze zapnout/vypnout, nekdy efektivnejˇ

´ ˇ ı 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´ ˇ ı pˇri výskytu problemu ´ automaticke´ spuˇsten´ ˇ ı: core post-mortem laden´ ˇ z´ıc´ımu procesu pˇripojen´ı k jiˇz beˇ ´ e´ laden´ ˇ ı vzdalen ...

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)

´ ı 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 ˇ svuj ´ nekomu ˇ ´ vysvetlit jinemu (i kdyˇz tomu nerozum´ı) ˚ kod

ˇ 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

IJC — Jazyk C

ˇ ı programu˚ Laden´

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.

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


Jazyk Knihovny

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

soubor iso646.h

inttypes.h

standardn´ı #pragma definice

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


Jazyk Knihovny

Standardn´ı knihovny C99

restrict ukazatel je jedinou pˇr´ıstupovou cestou k objektu. ´ Vhodne´ pro lepˇs´ı optimalizaci; kvalifikator restrict lze ˇ významu. kdykoli vynechat bez zmeny

IJC — Jazyk C


Jazyk Knihovny

169/252

IJC — Jazyk C

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

170/252

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

172/252


ˇ 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

´ 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




175/252

´ ı v prub ˇ Testovan´ ˚ ehu psan´ı programu testujte mezn´ı pˇr´ıpady:

´ 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, ...)

´ Muˇ jejich ˚ ze odhalit chyby, ale nemuˇ ˚ ze dokazat nepˇr´ıtomnost.

IJC — Jazyk C

176/252



vstup odpov´ıdaj´ıc´ı velikosti pole +-1 ´ prazdn´ y vstup obrovský vstup ´ ı znaky na vstupu specialn´

´ ı chyby testovaneho ´ Systematicke´ pokusy o vyvolan´ programu. ˇ ım, ale nen´ı to toteˇ ´ z. Souvis´ı s laden´

IJC — Jazyk C

177/252



´ Uvod do C++

´ ı Systematicke´ testovan´

Historie

´ v prub ˇ testujte kod implementace ˚ ehu ´ jako prvn´ı testujte jednoduche´ cˇ asti ´ 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ˇ

C C with classes ISO C ISO C++ ISO C ISO C++ ISO C ISO C++

´ ı 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´

Automatizace testu˚ ´ ı s pˇredchoz´ı verz´ı automaticke´ regresn´ı testy – porovnan´ ´ ´ nezavisl e´ testy – obsahuj´ı vstupy a oˇcekavan e´ výstupy ...

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

´ Poznamka: ”unit testing”, ”code coverage analysis” IJC — Jazyk C

IJC — Jazyk C

´ ı programu˚ Testovan´

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


ˇ ı ciz´ıho kodu ´ Laden´

173/252



´ ˇ ı Nastroje pro laden´


Nereprodukovatelne´ chyby

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



178/252

IJC — Jazyk C

179/252

IJC — Jazyk C

180/252



Charakteristika jazyka C++


Nevýhody C++

Pˇr´ıklady – pˇreklad a sestaven´ı programu Soubor ahoj.cc:

ˇ Obecneˇ vyuˇzitelný programovac´ı jazyk vyˇssˇ ´ı urovn e. ´

#include int main() { std::cout << " Ahoj! \n"; }

ˇ 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

Je standardizovaný (ISO/ANSI) ´ ren´ı knihoven. Podporuje abstraktn´ı datove´ typy a vytvaˇ ´ ˇ a´ kompatibilita) Nastupce jazyka C (zpetn

// tisk ˇ retˇ ezce

Efektivita

ˇ nekter ˇ ´ ´ ı pol´ı se Zdedil e´ problemy jazyka C (indexovan´ ´ ı sprava ´ pameti, ˇ ...) nekontroluje, manualn´

´ ı (UNIX, pˇrekladaˇc GNU C++): Zpusob zpracovan´ ˚

ˇ cnost) Objektova´ orientace (tˇr´ıdy, dediˇ ˇ zovat operatory ´ Moˇznost pˇreteˇ

Nen´ı zcela kompatibiln´ı s jazykem C ˇ Ne vˇsechny pˇrekladaˇce dostateˇcneˇ vyhovuj´ı norme.

g++ -o ahoj ahoj.cc ./ahoj

Genericke´ tˇr´ıdy a funkce (ˇsablony) Obsluha výjimek

IJC — Jazyk C

´ Poznamka: Pˇr´ıpony .cc, .cpp, .C, .c++, .cxx ˇ ı (UNIX, GNU C++): Optimalizace a laden´

´ Poznamka: Citace z Internetu: ”There are only two kinds of programming languages: those people always bitch about and those nobody uses.”

Mnoho ruzn´ ˚ ych implementac´ı pˇrekladaˇcu˚ Mnoˇzstv´ı prostˇredku˚ pro ruzn ˚ e´ aplikace (GUI, ...)

181/252


IJC — Jazyk C

g++ -O2 -o prog prog.cc g++ -g -o prog prog.cc gdb prog 182/252


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

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

# +optimalizace # +ladic´ ı informace # ladˇ en´ ı

IJC — Jazyk C

183/252


ˇ ´ Pˇr´ıklad: cˇ ten´ı a tisk C ˇretezce v C++ (nevhodne)

Pˇr´ıklad: cˇ etnost slov

ˇI ´VAT] // hroz´ ı chyba typu "buffer overflow" [NEPOUZ #include #include <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

using namespace std;

184/252


IJC — Jazyk C

185/252


// g++ -std=c++11 #include #include #include #include

map_t; mapiter_t;

// // // //

187/252

IJC — Jazyk C

IJC — Jazyk C

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

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 }

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

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

Pˇr´ıklad: ˇrazen´ı cˇ ´ısel, iterator

// kontejner std::map

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

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

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

// g++ -std=c++11 (nebo c++0x) #include #include <string> #include <map> // kontejner std::map

#include #include <string>

// std::string

188/252

IJC — Jazyk C

189/252



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

// // // //

// g++ -std=c++11 #include #include #include

vector sort, copy cout ostream_iterator

Rozd´ıly mezi C a C++ // cout // vector // sort, copy, for_each

´ ı 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:

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

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


Pˇr´ıklad: lambda funkce

190/252


IJC — Jazyk C

´ jsou typu char Znakove´ literaly sizeof(’a’) == sizeof(int) // C sizeof(’a’) == sizeof(char) // C++

191/252


IJC — Jazyk C

192/252


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

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

... Výcˇ tový typ nen´ı ekvivalentn´ı typu int enum e { A }; sizeof(A) == sizeof(int) // C sizeof(A) == sizeof(e) // C++ != sizeof(int)

anonymn´ı unie (jsou v C11) ˇ zovan´ ´ ı funkc´ı a operator ´ u˚ pˇreteˇ

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)

automaticka´ inicializace (konstruktory, destruktory) zapouzdˇren´ı (private, public, protected) ˇ cnost, nasobn ´ ˇ cnost dediˇ a´ dediˇ ´ ı funkce) polymorfismus (virtualn´ uˇzivatelem definovane´ konverze

193/252


IJC — Jazyk C

kl´ıcˇ ove´ slovo mutable

194/252


IJC — Jazyk C

195/252


´ ı Novinky v C++11 – pokraˇcovan´

Novinky v C++11 proti C++98

Novinky v C++14

R-hodnotove´ reference, ”move”konstruktory

´ silneˇ typovane´ výcˇ ty Nove,

constexpr ˇ ve specifikaci dat ”POD = Plain Old Data” Zmeny

´ v C++98) template> (problem ´ explicit pro konverzn´ı operatory

extern template

alias sˇ ablony ˇ ˇ ym poˇctem parametru˚ (”variadic Sablony s promenn´ templates”) ˇ ´ Nove´ rˇetezcov e´ literaly

auto parametry lambda funkc´ı ˇ ych sˇ ablony promenn´

´ (10kg, 12345bignum) Uˇzivatelem definovane´ literaly ´ Podpora vlaken (thread_local, ...)

ˇ ´ oddelovaˇ ce v numerických literalech 10’000’000 vylepˇsen´ı a rozˇs´ırˇen´ı std knihovny

Alternativn´ı syntaxe funkc´ı []fce(int x)->int{return x;} ´ ı identifikatory ´ Specialn´ override, final

default a delete konstruktory atd.

...

nullptr

Moˇznost implementovat ”garbage collector”

Inicializaˇcn´ı seznamy ´ Sjednocený zapis inicializace (int a{5};) Inference typu˚ (auto,decltype) for cyklus pˇres rozsah kontejneru Lambda funkce a výrazy

IJC — Jazyk C

v inicializaci statických objektu˚ je dovolen obecný výraz genericke´ datove´ typy – sˇ ablony (template, typename)

´ operatory new, delete, new[] a delete[] tˇr´ıdy (class), abstraktn´ı tˇr´ıdy

´ 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

´ ´ jmeno tˇr´ıdy a výcˇ tu je jmeno typu ukazatele na cˇ leny tˇr´ıd

typ reference

ˇ a zruˇsen´ı ruzn´ Male´ zmeny ˚ ych omezen´ı: auto f() { .... return x; }

C99 inicializace { .field=value, .... } ´ ı literaly ´ binarn´ 0b0110

long long ´ Poznamka: Pˇrekladaˇce a podpora C++14

static_assert 196/252

IJC — Jazyk C

197/252

IJC — Jazyk C

198/252




Kl´ıcˇ ova´ slova C++

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

´ 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


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

IJC — Jazyk C

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

and_eq bitor not or xor

&= | ! || ^

´ Poznamka: Trigraphs (??/)

(bude zruˇseno v C++17)

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

200/252

IJC — Jazyk C

201/252


´ Poznamky

ˇ s´ı neˇz v C: Je v C++ silnejˇ Deklarace:

´ (operator "") C++11: uˇzivatelem definovane´ literaly Pˇr´ıklad:

void (*funptr)();

BigNumber operator "" _big(const char * literal_string); BigNumber some_variable = 12345_big; ´ jsou typu: Znakove´ literaly char v C++ v C, v C++ pouze v´ıceznakove´ (mbc)

IJC — Jazyk C

ˇ e´ cyklu ve for Rozsah deklarace promenn

je ukazatel na fci vracej´ıc´ı void v C, ukazatel na fci vracej´ıc´ı void bez parametru˚ v C++

for(int i=1; i<10; i++) { // zde plat´ ı i }

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

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

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

lze vynechat kl´ıcˇ ove´ slovo enum pˇri pouˇzit´ı ´ ´ ı na hodnotach ´ prvku˚ sizeof výcˇ toveho typu zavis´ 202/252


IJC — Jazyk C

203/252


Typ reference

Bl´ızke´ ukazatelum ˚ (ale neexistuje obdoba NULL) ´ an´ ´ ı parametru˚ odkazem Pouˇzitelne´ pro pˇredav Nelze vytvoˇrit:

double x = 1.23456; double & xref = x; // Typick´ e pouˇ zit´ ı

const int & i = 7; // Vytvoˇ r´ ı pomocnou promˇ ennou int & i = 7; // CHYBA! nelze pro nekonst. referenci

double & yref; extern int & zref;

float f = 3.14; const int & ir = f; // pomocn´ a_promˇ enn´ a = 3 ir = 5; // CHYBA! konstantu nelze zmˇ enit

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

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

// Vracen´ ı reference: int & f(param); // Pozor na to _co_ se vrac´ ı!

Výhodou referenc´ı je jednoduchost pouˇzit´ı (na rozd´ıl od *ptr)

f(p) = 1;

// Vol´ an´ ı funkce

(C++11) 205/252

IJC — Jazyk C

204/252


// Pˇ red´ an´ ı parametru odkazem: void Transpose(Matrix & m);

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

IJC — Jazyk C

Reference — chybna´ nebo netypicka´ pouˇzit´ı

Typ reference – pˇr´ıklady

Definice: T & x = Lhodnota_typu_T;

´ Poznamka: R-hodnotove´ reference Typ &&

&& & ~ != |= ^=

´ Poznamka: Digraphs (<:)

Typova´ kontrola

´ u˚ je stejna´ jako v C. Syntaxe cˇ ´ıselných literal

IJC — Jazyk C

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


´ Literaly

int

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

206/252

IJC — Jazyk C

207/252



´ operatory ( ) [ ] -> :: . ! ~ + - ++ -- & * (Typ) sizeof new delete .* ->* * / % + << >> < <= > >= == != & ^ | && || ?: = *= /= %= += -= &= ^= |= <<= >>= ,

´ 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


IJC — Jazyk C

´ Operatory C++ asociativita → ← → → → → → → → → → → → ← ← →

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

209/252


´ Operatory — pˇr´ıklady

// alokace a ruˇ sen´ ı pole bajt˚ u: char *s = new char[100]; delete [] s; // char *s2 = static_cast(std::malloc(100)); // std::free(s2);

211/252


IJC — Jazyk C

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. 212/252

IJC — Jazyk C

213/252


Konverze — pˇr´ıklady

Explicitn´ı konverze ´ ı programator ´ Explicitn´ı konverze uvad´ do textu programu ˇ (a pˇreb´ıra´ za neˇ veˇskerou odpovednost):

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

´ Poznamka: ´ an´ ´ ı cˇ ´ısla int s cˇ ´ıslem unsigned muˇ Pˇri porovnav ˚ ze doj´ıt k (pro ˇ ´ ´ um: nekoho neoˇcekavan´ ym) problem ˚

4

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

5

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

int i = -1; unsigned u = 1234;

6

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

7

Jinak, jsou oba operandy typu int

if(i
(typ) v´ yraz typ(v´ yraz) static_cast(v´ yraz) Pˇr´ıklady:

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

214/252

IJC — Jazyk C

´ ı Explicitn´ı pˇretypovan´

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

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

IJC — Jazyk C

210/252

´ pˇri Implicitn´ı konverze prob´ıhaj´ı automaticky (jsou-li nutne) ´ ı binarn´ ´ ıch operac´ı: vyhodnocovan´


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

IJC — Jazyk C

Standardn´ı konverze v C++

´ ı 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

// uvolnˇ en´ ı pamˇ eti oper´ atorem delete: delete [] p; // uvolnˇ en´ ı pamˇ eti pole delete p2; // uvolnˇ en´ ı pamˇ eti objektu

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´


´ Operator ::

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

IJC — Jazyk C


´ Operatory C++ podle priority

Typ bool

215/252

IJC — Jazyk C

216/252




´ ı programu˚ Knihovny a sestavovan´

Preprocesor

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

´ 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ˇ

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

extern "C" int f(int);

lze nahradit za:

#define K1 10 const int K1 = 10;

extern "C" { int g(int); int h(int); }

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

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

´ Poznamky: relokace, Position Independent Code (PIC), linker, loader 217/252


IJC — Jazyk C

218/252


´ souboru˚ Formaty

1

2

3

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

220/252

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


1 2

´ Poznamka: libtool

221/252


´ ı programu Sestavovan´

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´

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

IJC — Jazyk C

219/252

´ ren´ı sd´ılený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ˇ

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

IJC — Jazyk C

222/252


Staticke´ sestaven´ı

pˇrekladaˇc (compiler):

´ vˇsech funkc´ı výsledný program obsahuje kod typicky se sestavuj´ı cele´ moduly z knihoven

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

gcc -static (implicitneˇ sestavuje dyn.) ld (POSIX), tlink (BC), ...

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

prog.c

m1.c

m2.c

m3.c

m4.c

prog.o

m1.o

m2.o

m3.o

m4.o

cc −c

Sestavovac´ı programy:

sestavovac´ı program (linker):

ar

crt1.o

libc.a

libtest.a

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

ˇ c (loader): zavadeˇ

ld

Nevýhody:

ˇ ı programu zajist´ı jeho naˇcten´ı do pameti ˇ pˇri spuˇsten´ a pˇr´ıpadne´ dynamicke´ sestaven´ı

IJC — Jazyk C

IJC — Jazyk C


´ ren´ı statických knihoven Vytvaˇ

COFF, PE (Windows), ELF (POSIX), ... Typicka´ struktura souboru:

IJC — Jazyk C

ˇ ı programu dynamicke´ – pˇri/po spuˇsten´

ˇ s´ı spustitelne´ soubory, vetˇ ´ knihoven nelze sd´ılet kod

223/252

IJC — Jazyk C

program

224/252

IJC — Jazyk C

225/252




Dynamicke´ sestaven´ı

Pouˇzit´ı knihoven prog.c

m1.c

m2.c

gcc −c

´ funkc´ı, program neobsahuje kod ˇ ı programu k sestaven´ı dojde aˇz po spuˇsten´

m3.c

m4.c

Pˇr´ıklad: Program s knihovnou libtest.a gcc -o program -static m1.c m2.c -L. -ltest

gcc −c −fPIC

prog.o

m1.o

ld.so = dynamic linker/loader Výhody:

m2.o

m3.o

m4.o

Pˇr´ıklad: Program s knihovnou libtest.so gcc -o program m1.c m2.c -L. -ltest

gcc −shared

´ moˇznost nezavisl e´ aktualizace knihoven, menˇs´ı programy, ´ sd´ılen´ı kodu knihoven

libc.so

´ Poznamky:

libtest.so

ˇ ı knihoven! Pozor na um´ısten´ Lze kombinovat staticke´ i dynamicke´

ld.so gcc

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

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

program

./program

process

´ Problemy: DLL hell, nekompatibilita verz´ı knihoven, ... IJC — Jazyk C

226/252


IJC — Jazyk C


´ ı Pouˇzit´ı knihoven – pokraˇcovan´

229/252


CFLAGS = -O2 -Wall -std=c99 CXXFLAGS = -g PROGS = program1 program2

ˇ 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

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

´ ı zavislost´ ´ Automaticke´ generovan´ ı gcc -MM *.cc >depend vloˇzen´ı do Makefile: -include depend

ˇ ren´ı cˇ asu: Meˇ pˇr´ıkaz time, funkce time(), clock(), instrukce RDTSC, performance counters, ...

´ ı Makefile Programy pro generovan´

Pouˇzit´ı programu˚ typu ’profiler’ (gprof, valgrind, ...). ´ ı pamet ˇ ’ove´ naroˇ ´ cnosti (memprof, ...) Zjiˇst’ovan´

qmake – Qt toolkit imake – X Window System 232/252

IJC — Jazyk C

231/252


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: 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), ...

CMake

IJC — Jazyk C

ˇ ´ cnost Casov a´ naroˇ

´ ˇ neoptimalizovat Zakladn´ ı pravidlo: radeji ˇ Pravidlo 90 — 10 (nekdy i 98—2) ´ ı kritických m´ıst v programech: Hledan´ ´ ej´ ˇ ıc´ı) Odhad (ˇcasto zavad

GNU Autoconf ./configure; make; make install

# ?=

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

Pˇr´ıklad: Pravidla v souboru Makefile:


Alternativy k make Jam, ...

IJC — Jazyk C

ˇ ych Pouˇzit´ı promenn´

Výkonnost programu˚ (performance)

Implementace GNU make, BSD make

228/252

Pˇr´ıklad

ˇreˇs´ı zavislosti ´ ´ ren´ı programu˚ pˇri vytvaˇ ´ a´ provad ´ en´ ˇ ı akc´ı podle zadaných pravidel uspoˇrad

/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


Program make

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:

IJC — Jazyk C

227/252

´ Poznamka: Neoptimalizujte co nema´ smysl 233/252

IJC — Jazyk C

234/252



ˇ ’ova´ naroˇ ´ cnost Pamet ˇ ’ova´ naroˇ ´ cnost Souvislost: cˇ asova´ x pamet Strategie:

´ Pˇrenositelný program lze pˇreloˇzit na v´ıce ruzn´ ˚ ych platformach (napˇr´ıklad UNIX, Linux/x86, Linux/PPC, Windows, MacOS X, ...)

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

Pˇrenositelne´ (multiplatform) knihovny – podstatneˇ ˇ ı psan´ı pˇrenositelných programu˚ (pˇr´ıklady: SDL, usnadnuj´ Qt, WxWidgets, ...). ´ Vhodne´ vývojove´ nastroje (GCC, make, ...).

obvykle se odhal´ı v´ıce chyb ´ cnejˇ ˇ s´ı na dodrˇzovan´ ´ ı standardu˚ naroˇ

´ volit vhodne´ datove´ formaty ´ cna) ´ (napˇr. de/komprese muˇ ˚ ze být cˇ asoveˇ naroˇ ˇ ’i a cache velikost pamet

”Cross development”– editace/pˇreklad/sestaven´ı neprob´ıha´ na c´ılove´ platformeˇ (duleˇ ˚ zite´ pˇredevˇs´ım pro ´ ”embedded”systemy).

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

´ Poznamky: lokalita odkazu, ˚ vliv CPU cache ´ rekurze (pˇr´ıklad: Ackerman) problem

Automaticka´ detekce konfigurace pˇri pˇrekladu – GNU autoconf: configure; make; make install (GNU build system: Automake, Autoconf, Libtool)

...

memory profiler: valgrind/cachegrind, ... IJC — Jazyk C


´ ı Pˇrenositelnost – pokraˇcovan´

Pˇrenositelnost (portability)

235/252


IJC — Jazyk C

236/252


Subversion

Tyto programy (Revision Control, Version Control Systems) ´ ı zmen ˇ pˇri vývoji programu. dovoluj´ı sledovan´ ˚ Pˇr´ıklady: Programy pro pˇreklad z jiných jazyku˚ do C: f2c – Fortran ˇ ˇ y assembler Nekter e´ jazyky pouˇz´ıvaj´ı C jako vysokourov ´ nov´ (pojem ”translator”, pˇr´ıklady: Cfront C++, Modelica)

238/252


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’

239/252


´ ´ velkými projekty (Linux, ...) Distribuovaný system, pouˇz´ıvan ´ ı repozitaˇ ´ r): Jednoduchý uvod (lokaln´ ´

svn commit

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

svn update -r cislorevize

## n´ avrat k zadan´ e revizi

IJC — Jazyk C

240/252


´ ı Git – pokraˇcovan´

Git

Pˇr´ıklady API

´ y repozitaˇ ´ r): Jednoduchý uvod (vzdalen´ ´ git clone host:/cesta/adresar ## staˇ zen´ ı repozit´ aˇ re cd adresar

ˇ eˇ vazan´ ´ Jednoduchý pˇr´ıklad: dlist.h – dvojsmern y seznam (+varianty: Linux lists) Knihovny:

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

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

´ ı 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´

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

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

IJC — Jazyk C

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

svn mkdir file:///home/xjmeno99/svnrep/projekt

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ˇ ˚

´ Poznamka: + podpurn ˚ e´ knihovny

mkdir adresar cd adresar git init

svnadmin create svnrep

Princip:

...

IJC — Jazyk C

Jednoduchý uvod (soubory, ne client-server): ´

SCCS (Bell-labs, 1980), RCS (198x), ... Klient-server: CVS (1986), Subversion (2000), ... ´ Git, GNU arch, Bazaar, Monotone, ... Distribuovane:

p2c – Pascal

237/252


´ reviz´ı Programy pro spravu

Konverzn´ı programy

IJC — Jazyk C

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

Obsah souboru˚ je (po commit) uloˇzen na alesponˇ 2 m´ıstech: ´ e´ — repo2-lokaln´ ´ ı — soubory repo1-vzdalen 241/252

IJC — Jazyk C

242/252

IJC — Jazyk C

243/252



´ Bezpeˇcnost – zaklady


´ UTF-8 – zaklady

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)

´ typu ”buffer overflow”(zasobn´ ´ Problem ık, heap, ...) – je nutne´ dobˇre oˇsetˇrit vstupy

UTF = ”UCS Transformation Format” UTF-8 (autor: Ken Thompson, kolem 1992)

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)

´ ”temporary file creation”– pozor na postup Problem ´ ren´ı jmen doˇcasných souboru˚ vytvaˇ ... ...

U00000000 U00000080 U00000800 U00010000 U00200000 U04000000

´ 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

... Pˇr´ıklady ´ steˇ u SUID programu˚ a serveru˚ Velmi duleˇ ˚ zite´ zvlaˇ

-

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

´ Poznamky: International Components for Unicode (ICU), Pango, Qt IJC — Jazyk C

244/252


245/252


UTF-8 – pouˇzit´ı

IJC — Jazyk C

246/252



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

IJC — Jazyk C


Konverze:

´ ˇretezce: ˇ Delka

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´

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

strcpy strcat strcmp strstr

ruˇsen´ı znaku

´ ´ ´ ı: Funkce zavisl e´ na lokalizaci ale ne na kodov an´

pozice znaku na obrazovce (ˇc´ınske´ zab´ıraj´ı 2 pozice)

strcoll strxfrm

247/252


IJC — Jazyk C

248/252


UTF-8 – pˇr´ıklady

IJC — Jazyk C

249/252


´ er ˇ – poznamky ´ Zav a souvislosti

UTF-8 – pˇr´ıklady Tisk sˇ irokých znaku: ˚ #include <stdio.h> #include

´ 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

Free Software, Projekt GNU Licence (GPL, LGPL, BSD, MIT, MPL, Apache, ...) ´ WWW stranka s odkazy

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

250/252

IJC — Jazyk C

... Co bude u zkouˇsky

251/252

IJC — Jazyk C

252/252

Charakteristika jazyka C

Recommend Documents