Posnetek Današnje konference je tule:
https://vox.arnes.si/p1ck9i6ap98/
Vsebina:
Inštalacija GCC … OK?
Na disku si ustvari en direktorij, kjer boš shranjeval vse svoje programe in primere, npr. na disku C, Mala Sola C:
C:\MSC\
Napišimo prvi program v C-ju. Kar primer iz druge lekcije:
#include
int main()
{
/* moj prvi C program */
printf(“Programiram v mali šoli C\n”);
return 0;
}
Odpri urejevalnik, notepad++ in vpiši gornji primer. Datoteko shrani v direktorij:
C:\MSC\Vaja1
pod ime prvi.c
Imeti moraš datoteko c:\MSC\Vaja1\prvi.c
Sedaj odpri komandno konzolo (Win-R, vnesi “cmd” in enter)
Sedaj se premakni na direktorij C:\MSC\Vaja1 z ukazom
CD C:\MSC\Vaja1
V konzoli se ti mora izpisati:
C:\MSC\Vaja1>
sedaj prevedi svoj program z ukazom:
gcc prvi.c -o prvi.exe
Drugi del lekcije.
Kako je C program sestavljen?
C program je (ponavadi) sestavljen iz:
predprocesorskih komand
funkcij
spremenljivk
stavkov in izrazov
komentarjev
Poglejmo naš program:
#include
int main()
{
/* moj prvi C program */
printf(“Programiram v mali šoli C\n”);
return 0;
}
Prva vrstica “#include ” je predprocesorska komanda, ki pove C programu naj vključi stdio.h v prevajajnje.
Naslednja vrstica “int main()” je glavna funkcija kjer se začne izvajanje programa.
Sledi komentar, ki se začne z /* in konča z */
Vrstica, ki vsebuje “printf(…)” je funkcija, ki izpiše besedilo na ekran.
Zadnja vrstica “return 0;” zaključi funkcijo “main()” in vrne rezultat 0.
/* ————————————————*/
ČLENI (Tokens)
V C-ju se vse posamezne besede, ločila, karakterji,… imenujejo členi (tokens). To so osnovni gradniki C-jezika.
Pa preštejmo člene v vrstici:
printf(“Programiram v mali šoli C\n”);
Teh je 5:
printf
(
“Programiram v mali šoli C\n”
)
;
Preprocesorske direktive (vrstice, ki se začnejo z #) niso členi. To so ukazi prevajalniku. S temi se bomo spoznali v naslednjih lekcijah.
Ključne besede (keywords)
Klučne besede so rezervirane besede ki se ne smejo uporabljati kot identifikator. C pozna 32 ključnih besed:
auto, break, case, char, const, continue, default, do, double, else, enum, extern, float, for, goto, if, int, long, register, return, short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, while
Podpičje
Podpičje zaključuje stavke. Vsak posamezen stavek mora biti zaključen s podpičjem.
Koliko stavkov je v našem programu?
Poglejmo, koliko stavkov se konča s podpičjem:
1. printf(“Programiram v mali šoli C\n”);
2. return 0;
Komentarji
Komentarji so pomožno besedilo v programu in jih prevajalnik ignorira. Komentar je vse, kar se začne z /* in konča z */. Vse, kar je vmes je komentar. Komentarji znotraj komentarjev niso dovoljeni. Prav tako ni možen komentar znotraj stringa.
Identifikatorji
Spremenljivke in funkcije v C-ju so lahko poljubna zaporedja znakov z nekaj pravili:
1. Začeti se mora obvezno s črko ali podčrtajem
2. Nadaljevanje so lahko črke ali številke
3. Drugi znaki niso dovoljeni
4. C loči velike in male črke
Operatorji
Operator je simbol, ki delujejo nad spremenljivkami ali vrednostmi. C ima veliko operatorjev, ki omogočajo zelo učinkovito pisanje programov. Razdeljeni so v več skupin, ki si jih bomo ogledali v nadaljevanju…
Aritmetični operatorji izvedejo aritmetično operacijo nad spremenljivkama ali med spremenljivko in konstanto.
+ Seštevanje
– Odštevanje
* Množenje
/ Deljenje
% Ostanek pri deljenju
Poskusimo, kako to deluje na primeru programa:
#include
int main()
{
int a = 9,b = 4, c;
c = a+b;
printf(“a+b = %d \n”,c);
c = a-b;
printf(“a-b = %d \n”,c);
c = a*b;
printf(“a*b = %d \n”,c);
c = a/b;
printf(“a/b = %d \n”,c);
c = a%b;
printf(“Ostanek pri deljenju a z b = %d \n”,c);
return 0;
}
Program shrani v c:\MSC\Vaja1\aritmetika.c
prevedi z
gcc aritmetika.c -o aritmetika.exe
Ali je rezultat razumljiv? Je kaj narobe? Koliko je 9/4 ?
Operatorji povečevanja in zmanjševanja (increment/decrement).
C ima dva operatorja za povečevanje (++) in zmanjševanje (–) za 1. Operatorja delujeta le nad eno samo spremenljivko (unary operator).
Uporablja se lahko kot predpona (prefix) ali končnica (postfix):
++a;
a++;
Poskusimo na primeru:
#include
int main()
{
int a = 10, b = 100;
float c = 10.5, d = 100.5;
printf(“++a = %d \n”, ++a);
printf(“–b = %d \n”, –b);
printf(“++c = %f \n”, ++c);
printf(“–d = %f \n”, –d);
return 0;
}
shrani v c:\MSC\Vaja1\incdec.c in prevedi
gcc incdec.c -o incdec.exe
Zdaj pa poskusi s primerom, kjer uporabiš operator kot končnico:
#include
int main()
{
int var=5;
// Najprej se izpise 5
// Potem se poveca na 6
printf(“%d\n”,var++);
// Sedaj je var = 6
// Najprej se poveca na 7, potem izpise
printf(“%d”,++var);
return 0;
}
shrani v c:\MSC\Vaja1\postpref.c in prevedi
gcc
Operatorji prirejanja
Ti operatorji spremenljivki priredijo vrednost.
Najpogostejši je enačaj:
= a=b
+= a+=b a=a+b
-= a-=b a=a-b
*= a*=b a=a*b
/= a/=b a=a/b
%= a%=b a=a%b
Lahko poskusimo še na primeru:
#include
int main()
{
int a = 5, c;
c = a; // c je 5
printf(“c = %d\n”, c);
c += a; // c je 10
printf(“c = %d\n”, c);
c -= a; // c je 5
printf(“c = %d\n”, c);
c *= a; // c je 25
printf(“c = %d\n”, c);
c /= a; // c je 5
printf(“c = %d\n”, c);
c %= a; // c = 0
printf(“c = %d\n”, c);
return 0;
}
shrani v c:\MSC\Vaja1\prirejanje.c in prevedi
gcc prirejanje.c -o prirejanje.exe
Operatorji primerjave
Ti preverijo v kakšnem odnosu sta dva operanda. Rezultat primerjave je 1, če je rezultat resničen in 0, če je rezultat neresničen.
== Enako
> Večje
= Večje ali enako
<= Manjše ali enako
Poskusimo z naslednjo vajo:
#include
int main()
{
int a = 5, b = 5, c = 10;
printf(“%d == %d je %d \n”, a, b, a == b);
printf(“%d == %d je %d \n”, a, c, a == c);
printf(“%d > %d je %d \n”, a, b, a > b);
printf(“%d > %d je %d \n”, a, c, a > c);
printf(“%d < %d je %d \n", a, b, a < b);
printf("%d < %d je %d \n", a, c, a = %d je %d \n”, a, b, a >= b);
printf(“%d >= %d je %d \n”, a, c, a >= c);
printf(“%d <= %d je %d \n", a, b, a <= b);
printf("%d <= %d je %d \n", a, c, a <= c);
return 0;
}
shrani v c:\MSC\Vaja1\primerjava.c in prevedi
gcc primerjava.c -o primerjava.exe
Logični operatorji
Podobno, kot operatorji primerjave logični operatorji vrnejo 1 ali 0, če je rezultat resničen ali neresničen. Operatorji so trije:
&& Logični in
|| Logični ali
! Logična negacija
Primeri:
imamo spremenljivki c in d, kjer je c = 5 in d = 2.
rezultat ((c==5) && (d>5)) je 0
rezultat ((c==5) && (d>1)) je 1
rezultat ((c==5) || (d>5)) je 1
rezultat !(c==5) je 0
Operatorji nad biti (Bitwise Operator)
Spremenljivke so znotraj računalnika vedno shranjene kot binarne vrednosti, sestavljene iz določenega števila bitov (enk in ničel). V C-ju lahko operiramo s posameznimi biti v spremenljivkah. Pri tem uporabljamo naslednje operatorje:
& konjunkcija (IN, angl. AND)
| disjunkcija (ALI, angl.OR)
^ izključujoči ALI (XOR)
~ komplement
<> bitni pomik v desno
Poglejmo si zapis vrednosti v dvojiškem zapisu z osmimi biti:
decimalno 12 = 00001100
decimalno 25 = 00011001
IN (AND) med 12 in 25:
00001100
& 00011001
________
00001000 = 8 (decimalno)
ALI (OR):
00001100
| 00011001
________
00011101 = 29 (decimalno)
XOR:
00001100
^ 00011001
________
00010101 = 21 (decimalno)
komplement (~)
decimalno 35 = 00100011 (binarno)
Komplement 35:
~ 00100011
________
11011100 = 220 (decimalno)
Ločiti moramo med dvojiškim komplementom (oblika zapisa predzančenih števil) in bitnim komplementom. Bitni komplement predznačenega števila je vedno -(N+1). Nekaj primerov je zbranih v tabeli:
Decimalno Binarno dvojiški komplement
0 00000000 -(11111111+1) = -00000000 = -0(decimalno)
1 00000001 -(11111110+1) = -11111111 = -256(decimalno)
12 00001100 -(11110011+1) = -11110100 = -244(decimalno)
220 11011100 -(00100011+1) = -00100100 = -36(decimalno)
Operatorji bitnega pomika, primeri:
212 = 11010100 (binarno)
212>>2 = 00110101 (binarno) [Pomik v desno za dva bita]
212>>7 = 00000001 (binarno)
212>>8 = 00000000
212>>0 = 11010100 (Enak rezultat, pomik za “0” mest)
212<<1 = 110101000 (binarno) [Pomik v levo za en bit]
212<<4 = 110101000000 (binarno) =3392(Decimalno)
Posebni operatorji
Vejica – loči izraze, ki so med seboj povezani, npr:
int a, c = 5, d;
Operator sizeof
Vrne velikost operanda v bajtih.
Še zadnji primer za danes:
#include
int main()
{
int a;
float b;
double c;
char d;
printf(“Velikost int=%lu bajte\n”,sizeof(a));
printf(“Velikost float=%lu bajte\n”,sizeof(b));
printf(“Velikost double=%lu bajtov\n”,sizeof(c));
printf(“Velikost char=%lu bajt\n”,sizeof(d));
return 0;
}
shrani v c:\MSC\Vaja1\sizeof.c, prevedi in poženi.
Za konec poglejmo še podatkovne tipe v C-ju
V C-ju imamo na voljo veliko različnih tipov podatkov, ki jih lahko določimo spremenljivkam. V osnovi se delijo na:
Osnovne tipe
Tip “void”
Enumerirane tipe
Izpeljane tipe
Osnovni tipi se delijo na:
Celoštevilčne (integer)
char 1 byte, -128 to 127 ali 0 to 255
unsigned char 1 byte, 0 to 255
signed char 1 byte, -128 to 127
int 2 ali 4 byte, -32,768 do 32,767 ali -2,147,483,648 do 2,147,483,647
unsigned int 2 ali 4 byte, 0 do 65,535 ali 0 do 4,294,967,295
short 2 byta, -32,768 do 32,767
unsigned short 2 byta, 0 do 65,535
long 4 byte, -2,147,483,648 do 2,147,483,647
unsigned long 4 byte, 0 do 4,294,967,295
long long 8 bytov, -9223372036854775807 do +9223372036854775807
unsigned long long 8 bytov, 0 do 18446744073709551615
Plavajoče (float)
float 4 byte, 1.2E-38 do 3.4E+38 (6 decimalk)
double 8 bytov, 2.3E-308 do 1.7E+308 (15 decimalk)
long double 10 bytov, 3.4E-4932 do 1.1E+4932 (19 decimalk)
Lepše in bolje poravnano je to opisano tule:
https://en.wikipedia.org/wiki/C_data_types
Poseben tip je “void”.
“void” tip se uporablja kadar tip ni določen. To je v treh primerih:
– Funkcija nič ne vrne.
– Funkcija nič ne sprejme.
– Kazalec tipa void*, ki predstavlja naslov objekta, ne pa njegovega tipa.
Enumerirani tip
Je poseben tip, ki je sestavljen iz celoštevilčnih konstat, ki so prirejene identifikatorjem v tem tipu. Sliši se komplicirano, vendar bo najlažje razumeti na primeru:
#include
enum teden {ponedeljek, torek, sreda, cetrtek, petek, sobota, nedelja};
int main()
{
// deklarirajmo spremenljivko enum tipa “teden”
enum teden danes;
danes = sreda;
printf(“Dan %d”,danes+1);
return 0;
}
shrani v c:\MSC\Vaja1\enum.c, prevedi in poženi.
Tisti, ki “programirate” v arduino okolju verjetno uporabljate TRUE in FALSE. To ni nič drugega kot enum tip, ki je definiran takole:
enum boolean {FALSE, TRUE};
Sedaj upam, da razumete, od kje to pride in da C programski jezike ne pozna tipa boolean ali TRUE in FALSE, kot to zavaja “programsko” okolje za arduino, kjer je še veliko osnovnih tipov skritih in zapakiranih v osnovne tipe.
/**************************************************************/
Naslednjič nadaljujemo s spremenljivkami in konstantami. Malo bolj podrobno si bomo ogledali tudi vnos in formatiranje izpisa.