Počítače a programování 1 pro obor EST KPC1E TUTORIÁL 2 OSNOVA: a) Základní struktura programu b) Algoritmy c) Vyjádření čísel a řetězců d) Data a proměnné e) Výrazy f) Aritmetické konverze g) Operátory h) Příkazy C – úvod i) Příkazy pro větvení j) Příkazy pro cykly I. 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: KPC1E_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: KPC1E_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: KPC1E_Ex02.c

Obecná definice vyjádření : Vyjádření čísel a řetězců (1/12) Obecná definice vyjádření : Používané soustavy :

Vyjádření čísel a řetězců (2/12) Používají se symboly 0 – 9, pro soustavy se základem nad 10 se přidávají písmena z abecedy: např. pro hexadecimální soustavu: A = 10 B = 11 C = 12 D = 13 E = 14 F = 15 Příklad hexadecimálního vyjádření : Číslo 0x3CF0 reprezentuje hodnotu: 3 · 4096 + 12 · 256 + 15 · 16 = 15600

Vyjádření čísel a řetězců (3/12) Numerické typy

Vyjádření čísel a řetězců (4/12) Numerické typy bez desetinné čárky pro celá čísla - bezznaménkové (unsigned) - uložení v paměti - znaménkové (signed) - uložení v paměti

Vyjádření čísel a řetězců (5/12) Příklad pro unsigned char (8 bitů) Příklad pro signed char (8 bitů) – standardní vyjádření

Vyjádření čísel a řetězců (6/12) Doplňkové kódování Příklad pro signed char (8 bitů) – doplňkové vyjádření Od absolutní hodnoty kódo-vaného záporného čísla je ode-čtena jednička, číslo je převede-no do dvojkové soustavy a je provedena jeho negace. Jednodušší hardware ALU

Vyjádření čísel a řetězců (7/12) Numerické typy s desetinnou čárkou pro racionální čísla - uložení v paměti (obecně podle IEEE754 normy) S je hodnota znaménkového bitu E je binární hodnota v exponentu M je binární hodnota v mantise

Vyjádření čísel a řetězců (8/12) Numerické typy s desetinnou čárkou pro racionální čísla Float (4 byty) Double (8 bytů)

Vyjádření čísel a řetězců (9/12) Float (4 byty)

Vyjádření čísel a řetězců (10/12) Double (8 bytů)

Řetězec: pole znaků (v paměti: 1 byte/znak – kód ASCII) Vyjádření čísel a řetězců (11/12) Řetězec: pole znaků (v paměti: 1 byte/znak – kód ASCII) NTS (Null Terminated Strings) : posledním znakem null – spec. znak v C/C++ ’\0’ Složky pole: ukazatele na znaky

Řetězec jako pole ASCII kódů znaků v paměti : Vyjádření čísel a řetězců (12/12) Řetězec jako pole ASCII kódů znaků v paměti :

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: KPC1E_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: KPC1E_Ex04.c int main(void) { int A[5] = {0, 1, 2, 3, 4}; int B[3][2] = {0, 1, 2, 3, 4, 5}; 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: KPC1E_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: KPC1E_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: KPC1E_Ex06.c + KPC1E_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: KPC1E_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: KPC1E_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: KPC1E_Ex10.c + KPC1E_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: KPC1E_Ex12.c

Operátory (4/10) Relační Příklad: KPC1E_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: KPC1E_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: KPC1E_Ex14.c

Operátory (6/10) Logické Příklad: KPC1E_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: KPC1E_Ex15.c

Operátory (7/10) Bitové Příklad: KPC1E_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: KPC1E_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: KPC1E_Ex17.c

Operátory (10/10) Přiřazovací Příklad: KPC1E_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: KPC1E_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;

Příkazy pro větvení (1/7) Podmíněný příkaz: if(test) statement; if(test) statement_this; else statement_that; příkaz podmínka - pravdivá - nepravdivá char day = '1'; if(day<48 || day >57) printf("Not a number\n"); else if(day>48 && day<56) // 1,2,3,…7 printf("Now is the %cth day\n", day); printf("An invalid day number\n");

Příkazy pro větvení (2/7) Větvení typu if

Příkazy pro větvení (3/7) Větvení typu if - else

Příkazy pro větvení (4/7) Kombinované větvení if – else if – else

Příkazy pro větvení (5/7) Podmínkový operátor ?: Test ? Statement_this : Statement_that; příkaz pro pravdivost příkaz pro nepravdivost podmínka Výběr z větší hodnoty: int a, b, c; a = 3; b = 9; c = (a > b) ? a : b; // c = 9 // if (a>b) c = a; // else c = b; Příklad: KPC1E_Ex19.c

Příkazy pro větvení (6/7) Přepínač swich-case: pro případy, kdy vybíráme z více než dvou možností výraz s výsledkem celočíselné hodnoty switch(value) { case 1 : statement_1; break; case 2 : statement_2; break; case 3 : statement_3; break; case 4 : statement_4; break; default: statement_other; } vystoupení z přepínače - není povinné příkaz vykonaný v případě jakékoli jiné hodnoty value

Příkazy pro větvení (7/7) Přepínač – příklad printf("Which girl should go to the cinema with me?\n"); srand(time(NULL)); switch(rand()%9) // random number from 0 to 8 { case 0: printf("Jana"); break; //if rand()%9 is 0 case 1: printf("Eva"); break; //if rand()%9 is 1 case 2: printf("Klara"); break; //if rand()%9 is 2 case 3: printf("Milena"); break; //if rand()%9 is 3 case 4: printf("Dominika"); break; //if rand()%9 is 4 case 5: printf("Erika"); break; //if rand()%9 is 5 case 6: printf("Petra"); break; //if rand()%9 is 6 case 7: printf("Zuzana"); break; //if rand()%9 is 7 default: printf("alone"); //if rand()%9 is not from 0 to 7, i.e. 8 } Příklad: KPC1E_Ex20.c

Ani jeden parametr není povinný: for( ; ; ) je nekonečná smyčka Příkazy pro cykly I. (1/5) Cyklus for for(init; test; update) statement;  Ani jeden parametr není povinný: for( ; ; ) je nekonečná smyčka char text[] = "Vjku\"oguucig\"ku\"ugetgv#"; unsigned int n; for(n=0; text[n]!='\0'; n++) // loop for all chars if(text[n]!=' ') // excluding space text[n] -= 2; // character code shift printf("%s\n", text); Příklad: KPC1E_Ex21.c

Příkazy pro cykly I. (2/5) for

Lichoběžníková aproximace: obsah pro jeden úsek: Příkazy pro cykly I. (3/5) Příklad - numerická integrace  Lichoběžníková aproximace: obsah pro jeden úsek:  Obecně:  Integrál: je součet všech dílčích ploch pro jednotlivé úseky

Příkazy pro cykly I. (4/5) Příklad - numerická integrace sin(x) pro interval 0 až π  Výpočet:  Program: #include <stdio.h> #include <stdlib.h> #include <math.h> #define pi 3.141529 int main(void) { double a[101], f[101]; //a = angle, f = func. value int n, i; double sum = 0, step; //step = lenght of interval int start = 3, stop = 100; // max. is 100

Příkazy pro cykly I. (5/5) Příklad: KPC1E_Ex22.c for(n=start; n<=stop; n++) { sum = 0; for(i=0; i<=n; i++) a[i] = 180.0*i/(n*1.0); f[i] = sin(a[i]*pi/180.0); } step = pi/(1.0*n); for(i=0; i<n; i++) sum += f[i]*step + (f[i+1]-f[i])*step/2.0; printf("\nFor %d intervals is integral %10.8f.", n, sum); Příklad: KPC1E_Ex22.c

Téma následujícího tutoriálu DĚKUJI ZA POZORNOST Téma následujícího tutoriálu Příkazy pro cykly II. Řetězce Pole