Mala šola C 002

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.

Share on FacebookTweet about this on TwitterShare on LinkedInFlattr the authorShare on Google+Print this pageShare on VKDigg thisShare on TumblrPin on PinterestShare on StumbleUponBuffer this pageShare on RedditEmail this to someoneShare on Yummly

Morda vam bo všeč tudi...

Dodaj odgovor

Vaš e-naslov ne bo objavljen. * označuje zahtevana polja