Transcript c - Ústav radioelektroniky

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
hlavička
hlavní
funkce
tělo
(definice)
funkce
//precompiled header files
#include <stdio.h> //standard inputs/outputs
int main(void)
{
char c;
//header of main function
//body of main function
//variable declaration
printf("ahoj"); //printing fnc. (stdio.h)
scanf("%c", &c);//wait until key pressed
(stdio.h)
return 0;
deklarace
proměnných
volané
knihovní
funkce
komentáře
}
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
• Založení nebo otevření projektu
nový projekt
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í
vložení ladící
zarážky
Příklad: BPC1E_Ex01.c
krokuje v programu
včetně vstupu do
funkcí, předčasně
lze funkci opustit
Základní struktura programu (10/10)
• Kde
Code::Blocks
stáhnout ?
Co stáhnout ?
codeblocks13.12mingwsetup.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
běžný příkaz
zobrazení výstupu
podmíněné
větvení
zpracování
souboru
uložení dat do
souboru
podprogram
cyklus s určeným
počtem opakování
cyklus s podmínkou na konci
cyklus s podmínkou na začátku
spojovací značka
spojovací čára
(tok algoritmu)
Algoritmy (5/6)
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í.
y1, 2
 b  b 2  4ac

2a
Algoritmy (6/6)
float a, b,
printf("a =
printf("b =
printf("c =
getchar();
c, y1, y2, r;
"); scanf("%f", &a);
"); scanf("%f", &b);
"); scanf("%f", &c);
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
Typ
Bitů
unsigned char
8
X  <0, +255>
char
8
X  <-128, +127>
short int
16
X  <-32.768; +32.767>
unsigned int
32
X  <0; +4.294.967.295>
int
32
X  <-2.147.483.648; +2.147.483.647>
float
32
1,18  10-38 < |X| < 3,40  10+38
double
64
2,23  10-308 < |X| < 1,79  10+308
long double
80
3,37  10-4932 < |X| < 1,18  10+4932
Rozsah
• 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
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;
*p = y;
// address of x to p
// 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
Výrazy (2/3)
• Operandy jako proměnné
int main(void)
{
int y1, y2, a=10, b=6;
char c;
y1 = a + b;
y2 = a / b;
//
//
a, b
+, /
are operands
are operators
printf("%3d\n", y1);
printf("%3d\n", y2);
scanf("%c", &c);
return 0;
}
Příklad: BPC1E_Ex06.c + BPC1E_Ex07.c
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
float
char
a
b
c
d
e
=
=
=
=
=
a, b, c;
d, e;
f = 'A';
3/5;
3/5.0;
f+1;
3/5;
3/5.0;
//
//
//
//
//
{int} =
{int} =
{int} =
{float}
{float}
printf("%3d\n", a);
printf("%3d\n", b);
printf("%3d\n", c);
printf("%6.2f\n", d);
printf("%6.2f\n", e);
Příklad: BPC1E_Ex09.c
//
//
//
//
//
{int}/{int}
{int}/{float}
{char->int}+{int}
= {int}/{int}
= {int}/{float}
0
0
66 (ASCII of 'A' is 65)
0.00
0.60
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í);
int a=1, b=6, c, d, e;
– logické (and, or, xor, …);
– relační (>, , ==, , <, , …); c = a<=b;
d = a!=b; // not equal
– přiřazovací (=, …).
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;
y = -(a + b) % c;
z = (-a + b) % c;
printf("%3d\n", x);
printf("%3d\n", y);
printf("%3d\n", z);
Příklad: BPC1E_Ex12.c
//-3 + (12 % 7) = -3 + 5 = 2
//-(3 + 12) % 7 = -15 % 7 = -1
//(-3 + 12) % 7 = 9 % 7 = 2
Operátory (4/10)
• Relační
int
a = 1, b = 6, c, d, e;
c = a <= b;
d = a != b;
e = a == b;
//a is smaller or equals b, c = 1
//a does not equal b, d = 1
//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
1 = pravda
• 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é
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é
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
Operátory (9/10)
• Inkrementace / dekrementace
double r1, r2, a1 = 5.1, a2 = 5.1, b = 4.2;
r1 = a1++ + b;
r2 = ++a2 + b;
//5.1+4.2=9.3
//1+5.1+4.2=10.3
printf("%6.2f\n",
printf("%6.2f\n",
printf("%6.2f\n",
printf("%6.2f\n",
a1);
r1);
a2);
r2);
Inkrementace, dekrementace: priorita = 2
Příklad: BPC1E_Ex17.c
Operátory (10/10)
• Přiřazovací
double r1=2.2, r2=3.3, a1=4.4, a2=5.5;
int
s1=4, s2=4;
r1 += a2-a1;
r2 /= a2-a1;
// r1=r1+(a2-a1) = 3.3
// r2=r2/(a2-a1) = 3.0
printf("%6.2f\n", r1);
printf("%6.2f\n", r2);
s1 <<= 2;
s2 >>= 2;
// 00000100b => 00010000b => 16d
// 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
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
C++;
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;
}
DĚKUJI ZA POZORNOST
Téma následující přednášky
– Příkazy pro větvení
– Příkazy pro cykly