Počítače a programování 1 pro obor EST BPC1E PŘEDNÁŠKA 3 OSNOVA: a) Základní struktura programu b) Algoritmy c) Data a proměnné d) Výrazy e) Aritmetické konverze f) Operátory g) Příkazy C - úvod Jiří Šebesta Ústav radioelektroniky, FEKT VUT v Brně

Základní struktura programu (1/10) Co je program? Jak program v C vytváříme? Jazyk symbolických adres = assembler = zčitelněný strojový (spustitelný) kód strojový (spustitelný) kód - instrukce (JSA) = operační kód - operandy (data, adresy)

Základní struktura programu (2/10) vložené hlavičkové soubory knihoven komentáře hlavička hlavní funkce //precompiled header files #include <stdio.h> //standard inputs/outputs int main(void) //header of main function { //body of main function char c; //variable declaration printf("ahoj"); //printing fnc. (stdio.h) scanf("%c", &c);//wait until key pressed (stdio.h) return 0; } tělo (definice) funkce deklarace proměnných volané knihovní funkce příkaz návratu z funkce s předáním návratové hodnoty (0)

Základní struktura programu (3/10) Způsoby řešení aplikací v C: KONZOLOVÁ APLIKACE (platformově nezávislá) – ANSI C APLIKACE PLATFORMOVĚ ZÁVISLÁ (pro konkrétní OS s využitím jeho funkcí, pro konkrétní kontrolér s využitím jeho konkrétních periferií) – rozsáhlé knihovní funkce, např. API, MFC, Active X Integrovaná vývojová prostředí IDE – kompletní nástroje pro tvorbu aplikací + průvodci (Wizards) pro nastavení projektu, například v MS Visual Studiu – open sourcová prostředí, např. Code::Blocks nebo Eclipse nebo CodeLite (není třeba licence)

Základní struktura programu (4/10) Code::Blocks – náš pracovní nástroj nový projekt Založení nebo otevření projektu otevřít už vytvořený projekt projekty pro jednočipy AVR 8 bitový ARM 32 bitový konzolová aplikace = textový výstup v DOS boxu

Základní struktura programu (5/10) Nastavení jazyka překladače (ANSI-C)

Základní struktura programu (6/10) Nastavení jména projektu

Základní struktura programu (7/10) Nastavení kompilátoru (GNU GCC) GNU – otevřený svobodný software (pakůň) GCC = GNU Compiler Collection

Základní struktura programu (8/10) Debug verze vs. release verze DEBUG – ladící verze – dokonalé ladění ale neoptimalizováno RELEASE – finální verze – optimalizovaný kód pro distribuci

Základní struktura programu (9/10) ladění a spuštění aplikace – menu DEBUG spustí ladění zastavuje se na ladících zarážkách zastaví ladění (program se může zacyklovat) krokuje v programu podle zdrojáku bez vstupu do funkcí krokuje v programu včetně vstupu do funkcí, předčasně lze funkci opustit vložení ladící zarážky Příklad: BPC1E_Ex01.c

Základní struktura programu (10/10) Kde Code::Blocks stáhnout ? Co stáhnout ? codeblocks-13.12mingw-setup.exe UŽITEČNÉ CZ WEBY: http://www.fit.vutbr.cz/~martinek/clang/ http://www.sallyx.org/sally/c/codeblocks/

Algoritmy (1/6) Algoritmus definuje postup činností (operací) „programu“ nad daty Základní rysy algoritmu: Konečnost – algoritmus se skládá z jednotlivých kroků, jejichž počet musí být konečný Vstupy/výstupy – algoritmus musí mít definovaný jednoznačné vstupy a výstupy (data, např. soubor) Determinovanost – algoritmus musí být přesně a jasně definovaný Efektivita – algoritmus musí být efektivní a optimálně využívat možnosti systému, na kterém je prováděn (efektivita z hlediska výkonného času vs. efektivita z hlediska využití operační paměti, příp. velikosti kódu)

Algoritmy (2/6) Univerzálnost – algoritmus musí být schopen pracovat s požadovanou množinou dat v definovaném rozsahu Základní elementy algoritmu: • Proměnné • Začátek algoritmu • Konec algoritmu • Kroky algoritmu • Podprogramy • Podmínky (binární relace) • Rozhodování • Sekvence • Cykly • Skoky (minimalizovat)

Algoritmy (3/6) Prostředky pro definici algoritmu: Slovní – přirozená forma: textový (myšlenkový) návod, vyhláška, zákon – často nepřesná definice, pak převod do programovacího jazyka není možný Grafický – vývojový diagram – přehledného znázornění složitějších algoritmů včetně větvení pomocí definovaných značek s popisem a orientovaných spojnic Symbolický – popis algoritmu pomocí přesně definované syntaxe (klíčová slova programovacího jazyka, který bude využit; metajazyk – generativní gramatika)

Algoritmy (4/6) Vývojový diagram - značky: začátek/konec algoritmu ruční vstup zobrazení výstupu běžný příkaz zpracování souboru podmíněné větvení uložení dat do souboru cyklus s určeným počtem opakování podprogram cyklus s pod-mínkou na konci spojovací značka cyklus s pod-mínkou na začátku spojovací čára (tok algoritmu)

Algoritmy (5/6) ax2 + bx + c = 0 Příklad vývojového diagramu pro program, který vypočítá kořeny libovolné kvadratické rovnice: ax2 + bx + c = 0 Hodnoty koeficientů nechť jsou načteny jako vstupy z konzolového okna. Vyjdou-li kořeny komplexní, vypíše se chybové hlášení.

Algoritmy (6/6) Příklad: BPC1E_Ex02.c float a, b, c, y1, y2, r; printf("a = "); scanf("%f", &a); printf("b = "); scanf("%f", &b); printf("c = "); scanf("%f", &c); getchar(); r = b*b-4*a*c; if(r>=0) { y1 = (-b+sqrt(fabs(r)))/(2*a); y2 = (-b-sqrt(fabs(r)))/(2*a); printf("\n 1st root: %.3f", y1); printf("\n 2nd root: %.3f", y2); } else printf("\n Result is not real"); Příklad: BPC1E_Ex02.c

Data a proměnné (1/8) Data – vstupní – I (Input), výstupní – O (Output) , pomocná (použité pro mezivýsledky algoritmu) Zdroje a cíle dat – soubor (I/O – binární, textový), klávesnice (I), konzola (O), tiskárna (O), komunikační brána (port) (I/O) - často jsou funkce pro práci se zdroji a cíli dat definovány jako funkce pro práci se souborem Druhy dat (proměnných) – numerické (celá nebo racionální čísla), znaky a řetězce (řetězec je pole znaků zakončené znakem NULL), pole (jednorozměrná = vektory, vícerozměrná = matice, 3D matice, …), ukazatel (odkaz na pozici v paměti), struktura (definovaná zapouzdřená množina proměnných různých typů)

Data a proměnné (2/8) Proměnná = pojmenované místo v paměti s požadovanou velikostí (v Bytech) GLOBÁLNÍ – platí v celém programu LOKÁLNÍ – platí jen v těle dané funkce #include <stdio.h> // standard inputs and outputs int a = 5; // global variable int main(void) // main function { int b = 10; // local variable char c; printf("global: %d\r\n", a); printf("local: %d\r\n", b); scanf("%c ", &c); return 0; } Příklad: BPC1E_Ex03.c

Data a proměnné (3/8) Numerické typy v ANSI-C short int = stačí definovat jen jako short V C99 celočíselný typ long long (8 B) v rozsahu <-263; 263-1>

Data a proměnné (4/8) Řetězec = pole znaků (typ char) kódovaných dle ASCII zakončené znakem NULL Řetězec se zapisuje do uvozovek: "toto je retezec" znak NULL se dosadí automaticky Znak = typ char, znak se zapisuje do apostrofů: ’a’, tím se do dané proměnné vloží ASCII hodnota tohoto znaku Speciální znaky: \b - backspace BS \f - form feed FF (také clear screen) \n - new line NL \r - carriage return CR \t - horizontal tab HT \v - vertical tab (ne všechny verze) \“ - znak uvozovka (ne všechny verze) \' - znak apostrof \\ - znak zpětného lomítka \ddd - znak ddd, kde ddd je ASCII kód znaku v okt. soustavě \xhh - znak hh, kde hh je ASCII kód znaku v hex. soustavě

Data a proměnné (5/8) Pole Příklad: BPC1E_Ex04.c int main(void) { int A[5] = {0, 2, 5, 7, 9}; int B[3][2] = {0, 4, 6, 9, 7, 1}; int i,j; char c; for(i=0; i<5; i++) printf("A[%d] = %d\r\n", i, A[i]); B[0][0] = A[4]; for(i=0; i<3; i++) for(j=0; j<2; j++) printf("B[%d,%d] = %d\r\n", i, j, B[i][j]); } return 0; Příklad: BPC1E_Ex04.c

Data a proměnné (6/8) Tisková funkce printf() (z knihovny stdio.h) int printf(const char* format, …) Zapíše formátovaný řetězec na standardní výstup Řetězec format obsahuje příslušný text v uvozovkách jako konstantní řetězec s speciálními znaky pro dosazovaní hodnot proměnných (a konstant): %d nebo %i – celočíselné dekadické vyjádření %o – celočíselné oktalové vyjádření %x – celočíselné hexadecimální vyjádření %f – vyjádření racionálního čísla %e – vyjádření racionálního čísla ve tvaru mantisa + exponent %c – znak (proměnná nebo konstanta nese ASCII kód znaku

Data a proměnné (7/8) Speciální znaky mohou obsahovat modifikátory, obecně: %[flags][width][.precision][length]specifier Např. kód: printf("Characters: %c %c \n", 'a', 65); printf("Decimal: %d \n", 500); printf("Floats: %4.2f %+.0e %E \n", 3.1416, 3.1416, 3.1416); má výstup: Characters: a A Decimal: 500 Floats: 3.14 +3e+000 3.141600E+000

Data a proměnné (8/8) Ukazatel (= adresa proměnné v paměti) #include <stdio.h> int main(void) { float x = 3.14, y = 2.27; float* p; // address of float variable p = &x; // address of x to p *p = y; // content of y on address in p return 0; } Příklad: BPC1E_Ex05.c

Výrazy (1/3) Výraz: konstrukce sloužící k výpočtu hodnot sestavujeme z operandů a operátorů Operand: proměnná, konstanta nebo volání funkce, která vrací hodnotu Operátor: symbol definující aritmetickou, logickou, přiřazovací, relační a další operaci nad operandy

Operandy jako proměnné Výrazy (2/3) Operandy jako proměnné int main(void) { int y1, y2, a=10, b=6; char c; y1 = a + b; // a, b are operands y2 = a / b; // +, / are operators printf("%3d\n", y1); printf("%3d\n", y2); scanf("%c", &c); return 0; } Příklad: BPC1E_Ex06.c + BPC1E_Ex07.c

Operand jako návratová hodnota po volání funkce Výrazy (3/3) Operand jako návratová hodnota po volání funkce ... #include "math.h" // library for math. functions int main(void) { double y, x=10000.2501; char c; y = sqrt(x); printf("Square root of %10.4f is %10.8f\n", x, y); scanf("%c", &c); return 0; } Příklad: BPC1E_Ex08.c

Aritmetické konverze (1/2) V ANSI-C platí: Všechny operandy typu … … char, short převedeny na int … float převedeny na double Je-li jeden z operandů typu … … double , druhý převeden též na double … long , druhý převeden též na long … unsigned, druhý převeden též na unsigned

Aritmetické konverze (2/2) Příklad aritmetických konverzí int a, b, c; float d, e; char f = 'A'; a = 3/5; // {int} = {int}/{int} b = 3/5.0; // {int} = {int}/{float} c = f+1; // {int} = {char->int}+{int} d = 3/5; // {float} = {int}/{int} e = 3/5.0; // {float} = {int}/{float} printf("%3d\n", a); // 0 printf("%3d\n", b); // 0 printf("%3d\n", c); // 66 (ASCII of 'A' is 65) printf("%6.2f\n", d); // 0.00 printf("%6.2f\n", e); // 0.60 Příklad: BPC1E_Ex09.c

Operátory (1/10) Unární (jediný operand): změna znaménka; logická negace; atd. int a=1, b=6; a = -a; // changing sign b = !b; // negation printf("%3d\n", a); //-1 printf("%3d\n", b); //0 Binární (dva operandy): aritmetické (sčítání, odčítání, násobení, dělení); logické (and, or, xor, …); relační (>, , ==, , <, , …); přiřazovací (=, …). int a=1, b=6, c, d, e; c = a<=b; d = a!=b; // not equal e = a==b; printf("%3d\n", c); //1 printf("%3d\n", d); //1 printf("%3d\n", e); //0 Příklad: BPC1E_Ex10.c + BPC1E_Ex11.c

Operátory (2/10) Aritmetické

Operátory (3/10) Příklad: priorita aritmetických operátorů (vyšší hodnota priority = nižší priorita) int a = 3, b = 12, c = 7; int x, y, z; x = -a + b % c; //-3 + (12 % 7) = -3 + 5 = 2 y = -(a + b) % c; //-(3 + 12) % 7 = -15 % 7 = -1 z = (-a + b) % c; //(-3 + 12) % 7 = 9 % 7 = 2 printf("%3d\n", x); printf("%3d\n", y); printf("%3d\n", z); Příklad: BPC1E_Ex12.c

Operátory (4/10) Relační Příklad: BPC1E_Ex13.c int a = 1, b = 6, c, d, e; c = a <= b; //a is smaller or equals b, c = 1 d = a != b; //a does not equal b, d = 1 e = a == b; //a equals b, e = 0 Příklad: BPC1E_Ex13.c

Operátory (5/10) výsledkem relačního operátoru je 0 = nepravda nebo relační operátory lze využít ve složených výrazech pro testování složitých podmínek int a = 3, b = 12, c = 7; x = a + b == c; //(3 + 12) == 7 => x = 0 y = a + (b == c); //3 + (12 == 7) = 3 + 0 => y = 3 z = a <= b + c != a; //(3 <= (12 + 7)) != 3 = //(3 <= 19) != 3 => z = 1; Příklad: BPC1E_ Ex14.c

Operátory (6/10) Logické Příklad: BPC1E_ Ex15.c int a = 3, b = 12, c = 7; x = !a || b; //!3 || 12 => 0 || 1 => x = 1 y = !(a || b); //!(3 || 12) => !(0 || 1) => y = 0 z = a || b && c;//3 || (12 && 7) => 0 || (1 && 1) //=> z = 1 Příklad: BPC1E_ Ex15.c

Operátory (7/10) Bitové Příklad: BPC1E_Ex16.c int b = 12, c = 7; x = b >> 2; //1100b => 0011b = 3 y = b & c; //1100b & 0111b = 0100b = 4 z = b ^ c; //1100b ^ 0111b = 1011b = 11 Příklad: BPC1E_Ex16.c

Operátory (8/10) Pravdivostní tabulka pro bitové operátory

Inkrementace, dekrementace: priorita = 2 Operátory (9/10) Inkrementace / dekrementace double r1, r2, a1 = 5.1, a2 = 5.1, b = 4.2; r1 = a1++ + b; //5.1+4.2=9.3 r2 = ++a2 + b; //1+5.1+4.2=10.3 printf("%6.2f\n", a1); printf("%6.2f\n", r1); printf("%6.2f\n", a2); printf("%6.2f\n", r2); Inkrementace, dekrementace: priorita = 2 Příklad: BPC1E_Ex17.c

Operátory (10/10) Přiřazovací Příklad: BPC1E_Ex18.c double r1=2.2, r2=3.3, a1=4.4, a2=5.5; int s1=4, s2=4; r1 += a2-a1; // r1=r1+(a2-a1) = 3.3 r2 /= a2-a1; // r2=r2/(a2-a1) = 3.0 printf("%6.2f\n", r1); printf("%6.2f\n", r2); s1 <<= 2; // 00000100b => 00010000b => 16d s2 >>= 2; // 00000100b => 00000001b => 1d printf("%3d\n", s1); printf("%3d\n", s2); Příklad: BPC1E_Ex18.c

Příkazy C – úvod (1/4) Program: posloupnost příkazů (vč. příkazů výrazové, např. volání funkcí) Pokud příkaz nepřenese řízení do jiné části programu nezpůsobí přerušení programu (interrupt) jsou příkazy vykonávány sekvenčně (za sebou) Příkaz standardní (ANSII C): uvozen rezervovaným slovem (např. for, if, else) pozn. rezervovaná slova jsou v Code::Blocks modře, nelze je používat jako jména proměnných

Stejný význam jako prázdný příkaz má prázdný blok { } Příkazy C – úvod (2/4) Prázdný příkaz if(err) goto lab1; // in case of error go to lab1 c++; // otherwise increment lab1: ; // label and empty command Stejný význam jako prázdný příkaz má prázdný blok { } Výrazový příkaz: přiřazení volání funkcí atd.

Příkazy C – úvod (3/4) Výrazový příkaz - příklad Složený příkaz: A=cos(b)+c; Složený příkaz: posloupnost příkazů uzavřená do složených závorek může obsahovat další složený příkaz: vnořený blok nadřazený blok

Příkazy C – úvod (4/4) Složený příkaz - příklad int main(void) { char text[40]="The momentary laps of ..."; int n, conv=0; for(n=0; n<strlen(text); n++) if(text[n]==' ') text[n+1] = text[n+1]-32; conv++; } printf("Mod.: %s (%d changed)", text, conv); getchar(); return 0;

Téma následující přednášky DĚKUJI ZA POZORNOST Téma následující přednášky Příkazy pro větvení Příkazy pro cykly