Gjuha E Programimit <c>

[iktuus]

MESIMI (1)
Në këtë udhëzues kemi për qëllim të mësuarit e programimit në një nga gjuhët më të famshëm dhe të përdorura në botë, C.

Një nga arsyet pse, deri tani, është e dobishme për të studiuar C është fakti se ka tashmë mijëra rreshta të kodit të shkruar që mund të zgjidhin pothuajse të gjitha problemet që lidhen me programimin (algoritme, strukturat, etj) .. C është një gjuhë, si Paskali dhe Fortran (të cilat janë të paraardhësit të saj), ju lejon të ruani vlerat në variablave, të strukturës së kodit të përcjellim rrjedhën e programit duke përdorur deklaratat e lak, deklaratat e kushtëzuar dhe funksione, kryejnë input / output ose një fotografi video, për të ruajtur të dhënat në vargjeve apo strukturat, por ndryshe nga këto gjuhë (dhe këtu forta e tij më të madh) ju lejon të kontrollit më saktë input / output, gjithashtu C është një gjuhë më të ngjeshur dhe ju lejon të shkruajnë programe të vogla dhe të lehta për t'u kuptuar.
Për ata që pyesin se çfarë jane aplikimet e vërteta te C, mjafton te dijn se me C mund të zhvillojnë programe të çdo lloji, duke përfshirë edhe video games, edhe praktikisht të gjitha sistemet operative janë zhvilluar kryesisht në Kuvend dhe C ( një në kernel Linux), edhe pse në vitet e fundit është gjithnjë e më shumë, duke përfshirë kodin e shkruar në C + + (shënim i autorit: ne C plus plus lexuar).

Nje neo programues mund të jete i frikësuar nga gjuha C, duke menduar C pak të avancuar dhe më pak e dobishme se gjuha më moderne, të tilla si Visual Basic, #, Python apo Java, kjo nuk është e vërtetë, C mëson se si të programoj, duke menduar se si të vendosim kodin, si te zgjidhim problemet qe kemi perball, ky sfond kulturor me siguri do të sherbej në të ardhmen, sepse sapo ju të mësoni C do të gjeni shumë më lehtë për të mësuar një gjuhë tjetër programimi, dhe madje mësohen bazat qe do të gjenden në gjuhët si C + +, Java, PHP, JavaScript, etj.

Për ata që janë duke e lexuar këtë udhëzues dhe nuk kanë asnjë përvojë në programim, ju duhet të lexoni Guide themelore për Programim në mënyrë që të kuptojnë më mirë këtë që po them në mësimet e ardhshme.

[iktuus]

JANE GATI 50 MESIME nese dikush do me jepte kenaqsin mos te postonte tek kjo tem do me bente nje nder mua dhe nje nder lexuesve per te pasur nje lidhje me te afert me mesimet

[iktuus]

MESIMI (2)
Një program zhvillohet duke shkruar kodin burim në një gjuhë te vlefshme të përcaktuar pikërisht nga sintaksa e gjuhës në vetvete.*Dallimi midis hartimit dhe interpretimit është shumë e rëndësishme dhe ndikon si në punën dhe mundësitë e gjuhës në vetvete.

Gjuhëve si C, C, Delphi, Visual Basic janë GJUHE TE HARTUARA, dhe ndjekin këto hapa: shkruan kodin në një redaktor, duke përdorur si mjedis zhvillimi një IDE që lehtëson krijimin, ky kod kontrollohet per te mos pasur gabime dhe me pas perpilohe, ose cdo udhëzim konvertohet në kodin përkatës në gjuhën e makinës që mund të ekzekutohet në këtë mënyrë nga procesori, dhe këto janë hartuar gjuhë, të cilat janë të njohur edhe si gjuhë e domosdoshme, dhe kanë përparësinë e nje prestacioni me te mire

GJUHE TE INTERPRETUARA , ndjekin një rrugë të ndryshme, kodi burim në fakt, interpretohet direkt dhe më pas ndiqen udhëzimet e përshkruar në kodin e burimit, një shembull është kodi PHP i cili kodi perpunohet*dhe kthen një faqe të pastër html.*Fuqia e kesaj lloj gjuhe është fakti qe trasporton ne menyr te menjëhershme ate që kemi shkruar dhe ajo që është paraqitur në zbatim, por ka probleme të tilla si gjetjen e gabimeve në kodin e burimit ose të ngarkesës*më shumë punë te procesorit (e cila duhet të përpunojë çdo kohë faqe).

Një gjuhë që është në gjysmë të rrugës në mes të këtyre metodave është Java qe eshte e hartuar, interpretuar, dhe kodi burimor është i hartuar në një format të ndërmjetëm (bytecode quhet), e cila nga interpretohet nga Java Virtual Machine (JVM), qe ka per detyr te interpretoj udhëzime bytecode në udhëzimet për procesorin, JVM është zhvilluar për çdo sistem operativ dhe ju lejon të nxjerri makinën virtuale krijuar nga OS të një nivel më të lartë të standardizimit (data se krijimi i makinës virtuale*në një tjetër makinë virtuale) që e bën atë në praktikë (JAVA) shumë te thjesht

Kjo metodologji përfshin aftësinë për të kontrolluar gabimet ne kodin burimor (në sajë të hartimit), për të krijuar programe relativisht të lehta (bytecode është një format file që krijon një madhësi te arsyeshme), por ka të metë qe ka prestacione jo te kenaqshme. Kjo*sepse kodi është interpretuar nga JVM, e cila nga ana duhet të delegojë ekzekutimin aktual të SO

[iktuus]

Vecantit e C MESIMI (3)
Jane te shumta, po rendisim me te rendesishmet duke i sqaruar kuptimin.
1)Dimensionin e kodit te vogel; zakonisht kodi burim i nje programi ne c ka n je peshe ne(kb) relativisht te vogel ne menyr qe kodin eshte me se i leht per tu traportuar nga nje PC ne tjetrin, madje edhe ne nje disket te thjesht floppy.
2)Madhesia e reduktuar e ekzekutueshme: edhe kur eshte kompiluar nje program ne C risulton gjithsesi shume i vogel dhe i thjesht per tu shperndar, padyshim qe nje program ne C mund te aplikohet vetem ne sistemin operativ qe eshte hartuar.
3)Efikasiteti i programit; nje program i shkruar ne C per madhesin e reduktuar dhe per madhesin e vene ne dispozicion nga gjuha per te menaxhuar deri ne fund memorien quhet vecanterisht i efektshem.
4)Mund te perpilohet ne nje game te gjere te PC; cdo PC mund te ndryshoj nga te tjeret per dy gjera, arkitektura dhe sistemi operativ. P.sh nje PC me procesor x86 dhe windows ka udhezime dhe menaxhime te ndryshme te memories nga nje Sparc te linux, por nje program ne C mund te perpilohet ne te dyja makinat nga disponibiliteti i perpilimit te platformave te ndryshme. Nuk eshte si JAVA per nga thjeshtesia por fakti qe eshte ne skene prej kohesh dhe shume i perhapur e bejn ate nje strument shume te perdorur.
5)Gjuhe e nivelit te larte; nje gjuhe programi quhet e nivelit te lart ne terma njerzore, dhe nje gjuhe e nivelit te ulet quhet ajo gjuhe e cila kodi eshte i afert me kodin e makines(ajo qe eshte formuar nga 0 dhe 1) nje shembull i gjuheve me nivel te ulet eshte ASSEMBLER ndersa nje gjuhe e nivelit te lart eshte C, C++, JAVA etj.Vecorit e gjuheve me nivel te lart eshte qe kemi nje nderfaqe te thjesht kur perdorim fjale anglisht per te pershkruar komandat qe korrispondojn udhezimet ne ASSAMBLER ose shume udhezime gjuhe makine.
6)Mund te menaxhoj aktivitete me nivel te ulet: gjuha programuese C konsiderohet si gjuha me nivel me te ulet ne gjuhet me nivel te lart.Kjo per shkak te faktit se ka pak udhezime, ne menyr efektive menaxhon memorien dhe mudn te futet direkt ne nje skedar C te kodit assambler.
7)Zbatimi i shigjetes: C bene nje perdorim te gjere te shigjetes per operacionet qe i perkasin, memories, strukturave, funzioneve etj.
8)Loose Typing; Ne C te dhenat e variablave nuk mund te behen te ditur ndryshe nga PASCAL, C++, JAVA qe duhen medoemos te behen te ditur. Ndryshimi qendron ne marrjen e vendimeve te projektuesit te gjuhes qe deshiron fleksibilitet ne brendesi te saj. Thuhet se metoda loose typing i lejon programatorit qe te bej gabime kompromentuese te ekzekutimit te programit.. Por eshte e vertet qe strong typing jemi te detyruar te ndjekim rregulla strikte qe ndonjehere nuk na lejon te zgjidhim se shpejti problemin.

[iktuus]

[I]MESIMI 4
Per te zhvilluar ne C jane te nevojshme dy strumente.
Nje sistem compilimi (perpilimi) si perpilues, linker, debugger, tool i programit etj, qe kontrollon per gabime dhe i kthen ne burim C ne nje ekzekutues
Dhe nje editor teksti.
Ndoshta ju ne pc tuaj mund te keni nje editor teksti, ketu do raportojm editoret qe permbushin nevoja te ndryshme si p.sh kush do te shkruaj kodin direkt nga shell linux dhe kush do nje sistem te integruar windows qe i lejon te perpiloj.
MICROSOFT WINDOWS
Hartuesit (perpilues) dhe mjedisi i zhvillimit.
DJGPP-porting i te famshmit GCC (hartues per makina UNIX/LINUX) lejon te perpilosh programe te shkruara ne C DHE C++ punohet ndermejt faqes RHIDE nje editor i ngjashem me EDIT i DOS.
DJGPP eshte nje editor falas qe ndoshta pak i veshtir per tu shkarkuar por eshte si per nevoja personale si per nevoja tregtare.Ky editor mund te perdoret ne sisteme DOS/WINDOWS por edhe me CALDERA DR-DOS dhe FREE DOS OS/2.
LCC-win32- Ky mjedis zhvillimi brenda tij ka cdo gje qe na nevojitet, hartues (assembler, linker etj) Nderfaqe vizuale per te shkruar kodin, ta korrigjosh etj. Eshte nje mjedis zhvillimi i kompletuar per C. Per qellime tregtare me duket eshte me pages ndersa per nevoja personale eshte version free.
DevC++- Eshte nje prodhim IDE (integrated delopment enviroment) qe dmth ZHVILLIM TE INTEGERUAR TE MEJDISIT. Eshte nje mjet zhvillimi qe ka nje editor efikas per windows dhe nje porting GCC si hartues.
BORLAND C++- Eshte nje nder me te miret si hartues, por versioni komplet i tij eshte me pages.
MICROSOFT VISUAL C++- Mjedis zhvillimi me i njohur ne bote natyrisht eshte me pages por nuk mund te thuhet qe eshte me i mire ne disponim.Hartuesit C/C++ kane nje nivel te mire, shtojm qe ne versionet e meparshme keta hartues kishin plot difekte. Ka nje nderfaqe te shkelqyer ( aftesi e teksteve te plot, te perdoresh wizard per te krijuar pjes te kodeve, integrim te librarive per te zhvilluar ne windows dhe te njejten gjuhe programi
. Eshte nje mjet zhvillimi qe ja vlen ta perdoresh.


Ndersa pèr sa i perket EDITORVE kemi te shume llojshme si p.sh NOTEPAD++ qe mund te perdoret per C/C++/JAVA/C#/PYTHON ETJ.
Tjeter editor eshte CONTEXT, FRHED(PER C++) ETJ.

[iktuus]

MESIMI 5
Ne mesimin 4 mesuam se cfare na nevojitej per sistemin operativ MICROSOFT WINDOWS ndersa ne kete mesim do mesojm ambjetin e zhvillimit dhe editoret per sistemin operativ LINUX.
HARTUES PER LINUX
GCC- eshte akronim i "GNU compiler collection" dhe na lejon te perpilojm kode ne gjuhet programuese si C, C++,OBJECTIVE-C, ADA, FORTRAN, JAVA, PASCAL dhe cdo lloj gjuhe programi qe ekziston Shpesh here me termin GCC nuk gjendet dallimi me "GNU C COMPILER ndersa per sa i perket gjuheve programuese si FORTRAN (GNAT) apo C++ (G++) dallimi eshte i rezervuar.GCC ka nje specifik te gjere dhe nese do hynim ne thellesi do na duheshin ore te tera per te shpjeguar, mjafton te dim qe GCC eshte nje perpilues dhe jo nje preprocesor, pra kodi burim i nje file qoft C ose C++ prodhon nje kod objekt me te mire dhe nje kontrollim me te sakt te gabimeve merite e GDB "Gnu Debugger" kjo. Te mesosh per ta perdorur eshte e thjesht p.sh per te perpiluar ne C mjafton te shtypesh nga konsole.
# GCC program. C
Te mesosh ta perdoresh mire dhe ta zoterosh ate ka ndryshim.
#man gcc
Ne kete udhezues do ju shpjegoj ne detaje opsionet e perpiluesit dhe gjithashtu sherbime te avancuar per te krijuar makefile.

EDITORET
KDevelop- ky editor nuk ka asnje arsye te jete mbrapa visual C++ i microsoftit, njeh automatikisht shtigjet ku keni instaluar software te nevojshem (si GCC dhe MAKE) eshte e mundshme te krijosh file ne C dhe C++ por edhe projekte komplet per dritaret LINUX Eshte nje nder me te mirat per LINUX por pak i veshtir per tu perdorur per amatoret qe duan te shkruajn ne C.
VIM- bashk me Emacs eshte nje nder me te miret EDITOR per linux.Vim eshte nje editor teksteti basuar tek VI (VI IMPROVED) ne karakteristikat e tij te shumta permendin hapjen e njekohshme te shume dritareve, te ndihmon online, scrolling horizontale,formatimin e tekestit, ndihmen per mousin,gjuhe e scripteve(shkrimit), perdorimin e plugin, vule automatike, ngjyr per tekestin etj.Pak i veshtir per tu perdorur, por nese krijojm pak kofidenca me te eshte i fuqishem.Eshte i disponueshme per te gjithe sistemet operative.
JEDIT- eshte per windows ashtu edhe per linux.
Editor te tjere janeMACS, QUANTA PLUS,GNU-Nano etj.

[iktuus]

MESIMI 6
Ne mesimin 4 dhe 5 mesuam softwaret qe na duhen per sistemet operative windows dhe linux. Ketu do bejm nje mesim te shkurter per MAC/OS (Macitonsh).
Softwaret qe duhen per MacOS jane;
GCC - Ne MacOS perpiluesi GCC eshte perfshir nga baza e nje sistemi BSD me emrin Darwin
CodeWarrior- eshte si per MacOS classic ashtu edhe per MacOS X. Po ashtu edhe per Windows, Linux,Solaris;PalmOS.Eshte nje produkt shume i mire, nuk eshte ne versionin free.
EDITORET.
Per sa i perket editorve Mund te zgjidhni EMACS, VIM DHE JEDIT (ky i fundit eshte me pak potent por me praktik)
keto editor xhirojn edhe ne sisteme te tjer si Windows dhe Linux.

[iktuus]

Mesimi 7
Te shkruajm ne C
Fillimisht shume gjera do jene te pakuptueshme, por nese do ndiqni mesimet atehere koncepti eshte me i qart sepse shume gjera nuk mund te shpjegohen vetem me dy fjale.
Programi i pare ne C, me i lehti ne perdorim eshte "Hello World" qe ka per qellim te thjesht per te shtypur fjalet ne ekran per te shpjeguar sintaksen themelore te gjuhes.
1) Hello world ne c
#include

main ()
{
printf("Hello World!");
}
Programi korrispondon edhe ne gjuhe programuese te tjera si:
2) Hello world ne Pascal
program main;

begin
writeln('Hello World!');
end.
3) Hello world ne C++
#include

main()
{
cout << "Hello World!";
}
4) Hello world ne Java
class Saluto {
public static void main(String args[]) {
System.out.println("Hello World!");
}
}

C eshte ndryshe nga Pascal, ka nje llogjik me praktike p.sh nuk duhet te deklarojm variablet jasht programit para se ta perdorim. Ndersa ne C++ ne ndryshim me C ka ne disponim komanda alternative dhe konstrukt te nje koncepti te ndryshem, si ne emra si ne sintaksa. Ndryshe nga Java ne C qe nuk nevojitet te bejm nje numer te deklaratave para se te shkruajm programin dhe nuk eshte e rendesishme te ndjekim rregulla te rrepta per te strukturuar programin.

[iktuus]

Mesimi 8
Elementet fondamental te nje programi ne C
Te shpjegohemi me mire...
#include

main ()
{
printf("Hello World!");
}
- #include eshte nje direktiv e preprocesorit, nje komand,qe na lejon te kerkojm librarit standarte te C, Pa librarit nje program nje program nuk do kishte ne dispozicion komandat per te ekzekutuer edhe operacionet me te thjeshta, si p.sh per te lexuar nje file ne ekran.
- main() ka nje funksion kryesor ne cdo pragram ne C, ne kete rast nuk ka parametra por mund te marrim dhena nga input i komandave. MAIN eshte mese i nevojshme duhet te jete i pranishem pergjithmon.
- Formatimi i teksteve sherbejn per te percaktuar blloqet e deklaratave, zakonisht quhen (statement) te cilat ndiqen ne urdher nga me e larta deri ne fund.
- Pikpresjet sherbejn per te mbyllur nje arsim, na lejon te kuptojm qe pas atij simboli fillon nje deklarat e re.
Duke hyre ne detaje te sintakses se gjuhes porgramuese C verejm qe funksioni i pare qe verejm dhe ai me i perdoruri eshte PRINTF() perdoret per te printuar ne ekran gjithshka qe i vjen si argument dhe bene pjes ne librarin , pa perfshirjen e kesaj nuk do kishte kuptim.
Ne brendesi te porgramit C mund te fusim komente ne dy menyra:
- //- Cdo gje qe ndodhet ne te djatht ne te njetin rrjesht konsiderohet koment dhe injorehet nga perpiluesi.
- /* ... */ Cdo gje qe eshte ne mes te dy asteriskeve konsiderohet koment ( kjo eshte nje form qe perdoret per komente ne me shume rrjeshta)

[iktuus]

MESIMI 9
PERPILIMI.
Ne program ne C mund te shkruhet edhe me nje editor te thjesht p.sh Blocco note e windows.Per te pa rezultatin e kodit duhet ta ruajm ne nje kartel p.sh "hello. c".
Nje program i perpiluar ne C ndjek keto faza;
- Kodi burim kontrollohet nga preprocesori, qe ndjek keto udhezime
1)te heqi komentet nga kodi burim
2)te interpretoj direktiva speciale per preprocesorin te dhena nga # si #include ose #define
3) te kontrolloj gabimet qe gjenden ne kodin.
-Rizultati i preprocesorit do te jete nje kod i ri burim "i paster" dhe "i perhapur" e cila perkthehet nga perpiluesi C ne kodin assembly.
- Assembler udhezohet per te krijuar kodin dhe ta ruaj ne nje file
-Linku editor udhezohet te lidhi te gjitha file objektet dhe zgjidhjen e cdo mangesie duke krijuar programin (qe nuk eshte gje tjeter pervecse nje file i ekzekutueshem)
Te gjitha keto operacione edhe pse jane te avancuara munde te gjejn gabime sintakse por nuk jane ne gjendje te gjejn gabime llogjike. Shpesh here sinjalizohen me WARNING qe nuk dmth gabime por pjes te kodit te cuditshme, ne kete menyr duhet te jemi te kujdeshem per gabime llogjike. Per kete duhet Debugger qe na ndihmon te zgjidhim dhe dallojm gabimet me strumentat si Breakpoint dhe Watchpoint
Nese kemi ne dore "hello.c" tani do na duhet ta perpilojm, me ambjentet e zhvillimit si DEV-C++ ose Visual C++ me komanden compile ose run programi do kryej te gjitha operacionet e permendura dhe kur te perfundoj do dergoj drejtimin e programit duke paraqitur rezultatin ne ekran.
Nese perdorim perpilues si DJGPP ose GCC hartimi duhet te jete nga vija e komandes dhe me vone perseri nga vija e komandes, duhet hedhur file ekzekutues qe rezulton (ne Linux me GCC file default i ekzekutueshem quhet a,out, ndersa ne windows quhet exe).
Per te perpiluar mjafton te pozicionohemi ne kartelen ku gjendet file burim dhe te shkruajm "# gcc hello.c"
Besoj keni krijuar nje ide si shkruhet dhe perpilohet nje program. Shume prej koncepteve do i hym ne thellesi avash avash duke proceduar si: strukturimi i gjuhes, perpilimi, funksionet disponibile te librarive.
SHEMBULL PRAKTIK.
11 #include
12 #include
13 #include
14
15 // SISTEMA = 1 -> Sistema Linux;
16 // SISTEMA = 0 -> Sistema Windows;
17 #ifndef SISTEMA
18 #define SISTEMA 0
19 #endif
20
21 // Scelgo la funzione di sistema per pulire lo schermo
22 #if SISTEMA==0
23 char* pulisci = "cls";
24 #elif SISTEMA==1
25 char* pulisci = "clear";
26 #endif
27
28 // Creo la struttura per contenere i contatti
29 typedef struct
30 {
31 char nome[50];
32 char cognome[50];
33 char telefono[30];
34 char email[100];
35 char sitoweb[200];
36 } t_contatto;
37
38 // Creo la struttura per creare la lista
39 struct elemento
40 {
41 t_contatto inf;
42 struct elemento *pun;
43 };
44
45 // Prototipi delle funzioni
46 void visualizzaContatto(struct elemento* p);
47 struct elemento *aggiungiContatto(struct elemento *p);
48 struct elemento *modificaContatto(struct elemento *p);
49 struct elemento *rimuoviContatto(struct elemento *p);
50 struct elemento *leggiDaFile(struct elemento *p);
51 int salvaSuFile(struct elemento *p);
52 void substring(char *dest, char *source, int i_base, int i_dim);
53 void pausa();
54
55
56 // Funzione principale - MAIN
57
58 int main()
59 { // MAIN() - OPEN
60
61 // dichiaro la variabile scelta e la lista vuota
62 int scelta;
63 struct elemento *lista = NULL;
64
65 // Ciclo infinito
66 for ( ; ; )
67 { // FOR - OPEN
68
69 // Stampo il menu
70 system(pulisci);
71 printf (" #######################\n");
72 printf (" # RUBRICA EASY v1.0 #\n");
73 printf (" #######################\n\n");
74 printf (" 1) VISUALIZZA CONTATTO\n\n");
75 printf (" 2) AGGIUNGI CONTATTO\n\n");
76 printf (" 3) MODIFICA CONTATTO\n\n");
77 printf (" 4) RIMUOVI CONTATTO\n\n");
78 printf (" 5) LEGGI CONTATTI DA FILE\n\n");
79 printf (" 6) SALVA CONTATTI SU FILE\n\n");
80 printf (" 0) ESCI\n\n\n\n");
81 printf (" la tua scelta > ");
82
83 // Aspetto scelta dell'utente
84 scanf ("%i", &scelta);
85 scelta = (int)scelta;
86
87 if (scelta == 0) // ESCO DAL PROGRAMMA
88 { // IF - OPEN
89
90 // Stampo info di uscita
91 system(pulisci); // PULISCE LO SCHERMO
92 printf ("--------------------------------------\n");
93 printf (" www.HTML.it - Rubrica Easy v1.0\n");
94 printf (" Programma creato da Fabrizio Ciacchi\n");
95 printf (" http://fabrizio.ciacchi.it\n");
96 printf (" fabrizio@ciacchi.it\n");
97 printf ("--------------------------------------\n\n");
98 break;
99
100 } // ELSE
101 else if (scelta == 1) // Visualizzo i contatti presenti
102 { // ELSEIF 1 - OPEN
103
104 visualizzaContatto(lista);
105
106 } // ELSEIF 1 - CLOSE
107 else if (scelta == 2) // Aggiungo un nuovo contatto
108 { // ELSEIF 2 - OPEN
109
110 lista = aggiungiContatto(lista);
111
112 } // ELSEIF 2 - CLOSE
113 else if (scelta == 3) // Modifico un contatto
114 { // ELSEIF 3 - OPEN
115
116 lista = modificaContatto(lista);
117
118 } // ELSEIF 3 - CLOSE
119 else if (scelta == 4) // Rimuovo un contatto
120 { // ELSEIF 4 - OPEN
121
122 lista = rimuoviContatto(lista);
123
124 } // ELSEIF 4 - CLOSE
125 else if (scelta == 5) // Leggo i contatti da File
126 { // ELSEIF 5 - OPEN
127
128 lista = leggiDaFile(lista);
129
130 } // ELSEIF 5 - CLOSE
131 else if (scelta == 6) // Salvo i contatti su File
132 { // ELSEIF 6 - OPEN
133
134 salvaSuFile(lista);
135
136 } // IF - CLOSE
137
138 } // FOR - CLOSE
139
140 } // MAIN() - OPEN
141
142 // Fine del MAIN, adesso ci sono le funzioni che eseguono il
143 // compito a loro assegnato
144
145 /*
146 * Visualizza i contatti presenti
147 */
148 void visualizzaContatto(struct elemento* p)
149 { // visualizzaContatto() - OPEN
150
151 if (p == NULL)
152 { // IF - OPEN
153
154 /*
155 * Se non ci sono contatti lo stampo a video
156 */
157 system(pulisci); // PULISCE LO SCHERMO
158 printf (" #######################\n");
159 printf (" # RUBRICA EASY v1.0 #\n");
160 printf (" #######################\n");
161 printf (" # VISUALIZZA CONTATTO #\n");
162 printf (" #######################\n\n");
163 printf (" Nessun contatto presente\n");
164 pausa();
165
166 } else { // ELSE
167
168 /*
169 * Stampo il primo contatto presente
170 */
171 system(pulisci); // PULISCE LO SCHERMO
172 printf (" #######################\n");
173 printf (" # RUBRICA EASY v1.0 #\n");
174 printf (" #######################\n");
175 printf (" # VISUALIZZA CONTATTO #\n");
176 printf (" #######################\n\n");
177 printf (" NOME > %s\n", p->inf.nome);
178 printf (" COGNOME > %s\n", p->inf.cognome);
179 printf (" TELEFONO > %s\n", p->inf.telefono);
180 printf (" EMAIL > %s\n", p->inf.email);
181 printf (" SITOWEB > %s\n", p->inf.sitoweb);
182 pausa();
183
184 } // IF - CLOSE
185
186 while (p != NULL)
187 { // WHILE - OPEN
188
189 /*
190 * Stampo gli altri contatti
191 */
192 system(pulisci); // PULISCE LO SCHERMO
193 printf (" #######################\n");
194 printf (" # RUBRICA EASY v1.0 #\n");
195 printf (" #######################\n");
196 printf (" # VISUALIZZA CONTATTO #\n");
197 printf (" #######################\n\n");
198 printf (" NOME > %s\n", p->inf.nome);
199 printf (" COGNOME > %s\n", p->inf.cognome);
200 printf (" TELEFONO > %s\n", p->inf.telefono);
201 printf (" EMAIL > %s\n", p->inf.email);
202 printf (" SITOWEB > %s\n", p->inf.sitoweb);
203 pausa();
204 // Leggo l'elemento successivo
205 p = p->pun;
206
207 } // WHILE - CLOSE
208
209 return;
210
211 } // visualizzaContatto() - CLOSE
212
213 /*
214 * Aggiungo un nuovo contatto
215 */
216 struct elemento *aggiungiContatto(struct elemento *p)
217 { // aggiungiContatto() - OPEN
218
219 system(pulisci); // PULISCE LO SCHERMO
220 printf (" #######################\n");
221 printf (" # RUBRICA EASY v1.0 #\n");
222 printf (" #######################\n");
223 printf (" # AGGIUNGI CONTATTO #\n");
224 printf (" #######################\n\n");
225
226 // Dichiaro le variabili
227 char nome[50];
228 char cognome[50];
229 char telefono[30];
230 char email[100];
231 char sitoweb[200];
232 t_contatto daInserire;
233 struct elemento *punt;
234
235 // Popolo la variabile daInserire
236 printf (" NOME > ");
237 scanf ("%s", nome);
238 strcpy(daInserire.nome, nome);
239 printf (" COGNOME > ");
240 scanf ("%s", cognome);
241 strcpy(daInserire.cognome, cognome);
242 printf (" TELEFONO > ");
243 scanf ("%s", telefono);
244 strcpy(daInserire.telefono, telefono);
245 printf (" EMAIL > ");
246 scanf ("%s", email);
247 strcpy(daInserire.email, email);
248 printf (" SITOWEB > ");
249 scanf ("%s", sitoweb);
250 strcpy(daInserire.sitoweb, sitoweb);
251
252 if(p != NULL)
253 { // IF - OPEN
254
255 /* creazione elementi successivi */
256 // Alloco la memoria necessaria
257 punt = (struct elemento *)malloc(sizeof(struct elemento));
258 // Metto daInserire nell'informazione del puntatore
259 punt->inf = daInserire;
260 // Metto il puntatore in testa alla lista
261 punt->pun = p;
262
263 } else { // ELSE
264
265 /* creazione primo elemento */
266 // Alloco la memoria necessaria
267 p = (struct elemento *)malloc(sizeof(struct elemento));
268 // Metto daInserire nell'informazione del puntatore
269 p->inf = daInserire;
270 // p punta a NULL, ovvero il marcatore di fine lista
271 p->pun = NULL;
272 // Assegno p a punt
273 punt = p;
274
275 } // IF - CLOSE
276
277 // Esce dalla funzione e restituisce la lista
278 return(punt);
279
280 } // aggiungiContatto() - CLOSE
281
282 /*
283 * Modifico un contatto presente
284 */
285 struct elemento *modificaContatto(struct elemento *p)
286 { // modificaContatto() - OPEN
287
288 // Dichiaro le variabili

[289 - 294 omissis]

295 struct elemento *twin = p;
296 int subscelta;
297 int i=1;
298 int n=1;
299
300 // Stampo la schermata
301 system(pulisci); // PULISCE LO SCHERMO
302 printf (" #######################\n");
303 printf (" # RUBRICA EASY v1.0 #\n");
304 printf (" #######################\n");
305 printf (" # MODIFICA CONTATTO #\n");
306 printf (" #######################\n\n");
307
308 // Stampo la lista di contatti
309 while (p != NULL)
310 { // WHILE - OPEN
311
312 printf ("%i) \t %s \t %s\n", i, p->inf.nome, p->inf.cognome);
313 // Leggo l'elemento successivo
314 p = p->pun;
315 i++;
316
317 } // WHILE - CLOSE
318
319 // Ottengo il valore originario di p
320 p = twin;
321
322 // Scelgo l'emento da modificare
323 printf("\n\n Inserisci il numero del contatto che vuoi modificare: ");
324 scanf("%i", &subscelta);
325
326 for (n=1; n 327 { // FOR - OPEN
328
329 /*
330 * Trovato l'elemento modifico l'informazione dentro di esso
331 */
332 if (subscelta == n)
333 { // IF - OPEN
334
335 // Popolo la variabile daInserire
336 printf (" NOME [%s] > ", p->inf.nome);
337 scanf ("%s", p->inf.nome);
338 printf (" COGNOME [%s] > ", p->inf.cognome);
339 scanf ("%s", p->inf.cognome);
340 printf (" TELEFONO [%s] > ", p->inf.telefono);
341 scanf ("%s", p->inf.telefono);
342 printf (" EMAIL [%s] > ", p->inf.email);
343 scanf ("%s", p->inf.email);
344 printf (" SITOWEB [%s] > ", p->inf.sitoweb);
345 scanf ("%s", p->inf.sitoweb);
346
347 } // IF - CLOSE
348
349 p = p->pun;
350
351 } // FOR - CLOSE
352
353 // Esce dalla funzione e restituisce la lista
354 return twin;
355
356 } // modificaContatto() - CLOSE
357
358 /*
359 * Rimuovo un contatto
360 */
361 struct elemento *rimuoviContatto(struct elemento *p)
362 { // rimuoviContatto() - OPEN
363
364 // Dichiaro le variabili
365 struct elemento *aus;
366 struct elemento *twin = p;
367 int subscelta;
368 int i=1;
369 int n=1;
370
371 // Stampo la schermata
372 system(pulisci); // PULISCE LO SCHERMO
373 printf (" #######################\n");
374 printf (" # RUBRICA EASY v1.0 #\n");
375 printf (" #######################\n");
376 printf (" # RIMUOVI CONTATTO #\n");
377 printf (" #######################\n\n");
378
379 // Stampo la lista di contatti
380 while (p != NULL)
381 { // WHILE - OPEN
382
383 printf ("%i) \t %s \t %s\n", i, p->inf.nome, p->inf.cognome);
384 p = p->pun; // scorre di un elemento
385 i++;
386
387 } // WHILE - CLOSE
388
389 // Ottengo il valore originario di p
390 p = twin;
391
392 // Scelgo l'emento da eliminare
393 printf("\n\n Inserisci il numero del contatto che vuoi rimuovere: ");
394 scanf("%i", &subscelta);
395
396 if (subscelta < i)
397 { // IF - OPEN
398
399 // Se la lista èvuota esco
400 if(p == NULL)
401 return;
402
403 // Se la lista ha almeno due elmenti...
404 if(p->pun != NULL)
405 { // IF - OPEN
406
407 // ... inizializzo un puntatore ausiliario ...
408 aus=p;
409 n++;
410
411 // ... e faccio un ciclo per trovare l'elemento da eliminare ...
412 while(n != i)
413 { // WHILE - OPEN
414
415 // Trovato l'elemento gli faccio puntare l'oggetto puntato dal suo
416 // puntatore, in poche parole "salto" l'elemento da eliminare
417 if(subscelta == n)
418 { // IF - OPEN
419
420 aus->pun=aus->pun->pun;
421
422 } else { // ELSE
423
424 // Nel caso in cui il puntatore fosse NULL, per non creare casini
425 // glielo assegniamo direttamente
426 aus=aus->pun;
427
428 } // IF - CLOSE
429
430 n++;
431
432 } // WHILE - CLOSE
433
434 } // IF - CLOSE
435
436 /*
437 * Se si vuole rimuovere il primo elemento, si assegna
438 * a p il valore del suo oggetto puntato; questo accade
439 * quando subscelta == 1
440 */
441 if(subscelta == 1)
442 { // IF - OPEN
443
444 p=p->pun;
445
446 } // IF - CLOSE
447
448 } // IF - CLOSE
449
450 // Copia di nuovo il valore p modificato in twin
451 twin = p;
452
453 // Esce dalla funzione e restituisce la lista
454 return twin;
455
456 } // rimuoviContatto() - CLOSE
457
458 /*
459 * Leggo i contatti dal file rubrica.txt
460 */
461 struct elemento *leggiDaFile(struct elemento *p)
462 { // leggiDaFile - OPEN
463
464 // Dichiaro le variabili
465 t_contatto daInserire;
466 t_contatto vuoto; // elemento vuoto
467 struct elemento *punt = p;
468 char linea[500]; // stringa per l'acquisizione
469 int index=0; // inizializza l'indice
470
471 // Apre il file
472 FILE *stream = fopen("rubrica.txt","rt");
473
474 // Salvo la lista di contatti
475 while(fgets(linea, 500, stream) != NULL)
476 { // WHILE - OPEN
477
478
479 index = strcspn(linea, ",");
480 strncpy(daInserire.nome, linea, index);
481 substring(daInserire.nome, daInserire.nome, 0, index-1);
482 substring(linea, linea, index+1, strlen(linea));
483 index = strcspn(linea, ",");
484 strncpy(daInserire.cognome, linea, index);
485 substring(daInserire.cognome, daInserire.cognome, 0, index-1);
486 substring(linea, linea, index+1, strlen(linea));
487 index = strcspn(linea, ",");
488 strncpy(daInserire.telefono, linea, index);
489 substring(daInserire.telefono, daInserire.telefono, 0, index-1);
490 substring(linea, linea, index+1, strlen(linea));
491 index = strcspn(linea, ",");
492 strncpy(daInserire.email, linea, index);
493 substring(daInserire.email, daInserire.email, 0, index-1);
494 substring(linea, linea, index+1, strlen(linea));
495 strcpy(daInserire.sitoweb, linea);
496 substring(daInserire.sitoweb, daInserire.sitoweb, 0, strlen(daInserire.sitoweb)-2);
497
498 // Aggiunge l'elemento alla lista
499 p = punt;
500 punt = (struct elemento *)malloc(sizeof(struct elemento));
501 punt->inf = daInserire;
502 punt->pun = p;
503
504 // azzera il valore di daInserire
505 daInserire = vuoto;
506
507 } // WHILE - CLOSE
508
509 // Chiude il file
510 fflush(stream);
511 fclose(stream);
512
513 // Esce dalla funzione e restituisce la lista
514 return(punt);
515
516 } // leggiDaFile - CLOSE
517
518 /*
519 * Salvo i contatti inseriti in un file di nome rubrica.txt
520 */
521 int salvaSuFile(struct elemento *p)
522 { // salvaSuFile() - OPEN
523
524 // Apre il file
525 FILE *stream = fopen("rubrica.txt","w");
526
527 // Salvo la lista di contatti
528 while (p != NULL)
529 { // WHILE - OPEN
530
531 // Scrive sul file
532 fprintf(stream, "%s,%s,%s,%s,%s\n", p->inf.nome, p->inf.cognome, p->inf.telefono, p->inf.email, p->inf.sitoweb);
533 // legge l'emento successivo
534 p = p->pun;
535
536 } // WHILE - CLOSE
537
538 // Chiude il file
539 fflush(stream);
540 fclose(stream);
541
542 // Esce dalla funzione
543 return;
544
545 } // salvaSuFile() - CLOSE
546
547 /*
548 * Funzione che prende una sottostringa partendo da un'indice
549 * base per un numero di caratteri pari a dimensione
550 */
551 void substring(char* dest, char *source, int i_base, int i_dim)
552 { // substring() - OPEN
553
554 int i = 0;
555
556 for (i=i_base; i 557 { // FOR - OPEN
558
559 dest[i-i_base] = source[i];
560
561 } // FOR - CLOSE
562
563 dest[i]='\0';
564
565 return;
566
567 } // substring() - CLOSE
568
569 /*
570 * Funzione che blocca lo schermo ad aspetta che l'utente
571 * prema INVIO
572 */
573 void pausa()
574 { // pausa() - OPEN
575
576 char invio;
577 printf("\n\n - premi INVIO per continuare -\n");
578 invio = getchar();
579 return;
580
581 } // pausa() - CLOSE

[iktuus]

Ne mesimet e ardhshme do mesojm elementet baze te gjuhes, pragramuese C sic jane: variabilet, operatoret dhe nderhyrjet, operazionet input/output, rregullat per te shkruar pa gabime etj.
Kjo eshte nje paradhenie per argumentet e mevonshme...

[iktuus]

Mesimi 10
VARIABILET
Eshte e rendesishme te mesojm kuptimin e variabileve ,mqs do e perdorim shpesh kete term. Mendojm kur regjistrojm numrin e telefonit te nje shoku ne celularin tone, nese deshirojm ta telefonojm mjafton te vendosim emrin (emrin e variabileve) dhe celulari do na nxjerri ne skerm numrin e tij qe duam ta telefonojm (vleren e variabileve) Variabile dmth e ndryshueshme.
Mund te themi qe ne nje variabil ekziston funksionimi i emrit dhe vleres qe korrispondon; kemi komoditetin (si celulari) te perdorim emerin per vleren, qe mund te jene numra ose shkronja, te sasive te medha qe nuk mund ti kujtojm lehte. Nje tjeter avantazh eshte perdorimi i emrit te varibileve ne vend te vleres se tij per te ndjekur operacione, qe na lejon te modifikojm vlerewn kur dhe si te duam.
Variabilet jane nje kontenitor i identifikuar me nje emer te vecant, te cdo lloj vlere qoft numer ose rresht (vargje). Per te bere ndonje gje konkrete ne brendesi te programit duhet te perdorim variabilet, ku korrispondenza emer-vlere na lejon qe te menaxhojm ndrushojm vleren ne te cilen lidhet, duke na dhene dinamizmin e nevojshem per te kryer operacione komplekse ose operacione te perseritura pa u sforcuar.
Lloji i variabilet tregon se cfare vlere mund te marr kontenitori i variabilit, kuptohet qe nje lloj i tere permban vetem numra,ndersa tipi tjeter do permbaj vetem shkronja te alfabetit, P.sh nje numer mund te trajtohet ndryshe ne variabilet qe mbajn vetem shkronja ai mund te konsiderohet si nje simbol dhe jo nje numer.
Cdo gje ka nje shpjegim llogjik qe shtrihet ne perafqsimin e numrit te vete, ne qoft se integer shtat eshte perfaqsuar nga nje byte (tet byte) si 00000111, karakteri 7 perfaqsohet me nje byte duke ndjekur ate qe eshte kodifikimi ASCII, qe duket ne nivel byte 00110111 qe ekuivalon ne nje prezantim te gjithshem te 55. Operacionet qe lejojn konvertimin e variabileve nga nje tip ne nje tjeter marrin emrin e Casting.
Te gjithe variabilet perpara se te perdoren duhen deklaruar, pra duhet ti themi perpiluesit emrin dhe llojin e variabilet (p.sh int x) kjo per te mundesuar te ndaj kujtesen e nevojshme te variabilit ne fjale: deklarimi zakonisht behet ne fillim te programit por ne programe te dimensioneve te medha mund te behet edhe ne pozicione te ndryshme, deklarimi i variabilit behet vetem nje here.
Me pas variabili duhet te jete i nisur pra duhet dhene vlera, operacion qe zakonisht behet ne nje kohe me deklarimin.
// vetem deklarimi
int x;
//nisja
x = 10;
//deklarimi dhe nisja
int y =15;

[iktuus]

Mesimi 11
Variabilet ne C.
Ne gjyhen programuese C ekzistojn disa lloje variabile, kjo per shkak te disa arsyeve si per nevojat e raprezentimit te shifrave te medha si per te kursyer ne menyren me efikase memorien, duke perdorur cdo here llojin e specifikuar per situaten e duhur.
Me posht do permend disa lloje dhe kuptimin qe i perdorim ne C, nje shpjegim per te dhenat qe raprezentojn dhe numrin e byte te nevojshem.
Lloji i deklarimit Raprezentimi Nr i byte
char karakteri 1 (8 bit)
int integer (numri i plot) 2 (16 bit)
short numri i plote (i shkurter) 2 (16 bit)
long numri i plote (i gjate) 4 (32 bit)
float numri real 4 (32 bit)
double numeri real (i gjate) 8 (64 bit)
Lloji CHAR eshte i detyruar te mbaj vetem nje karakter, ky imponim, i papershtatshem kur duam te ruajm ne memorie nje sere shkronjash eshte zgjidhur ne disa gjuhe duke pershtatur llojin string (rrjesht), ndersa ne C kjo situate zgjidhet duker perdorur nje array te char, array eshte nje kontenitor i variabilit i te njejti lloj. Char mund te permbaj nje karakter te percaktuar sipas standartit ASCII dhe mund te permbaj cdo shkronj (te vogel ose te madhe) shifra (nga 0-9) dhe simbole te parashikuar nga kodifikimi. Per te deklaruar dhe nisur nje vaiabile char, psh nisur me shkronjen "r" mjafton te shkruajm
char a = ' r ' ;
Lloji INT eshte ai qe mund te mbaj numra. Tipi INT ka dy variante qe jane te llojin shortdhe long.Lloji INT mban numra qe ne matematik quhen numra real kjo pa presje dhe pjes te coptuara. Do japim nje shembull nje pjese te kodit ku deklarohen dhe nisen variabilet int, dhe per te kuptuar si eshte bere int i raprezentuar ne numra natyral, ndjekim operacionin e ndarjes te dy numrave te plot (duke perdorur operatorin e ndarjes)
nt x = 7;
int y = 3;
int z;

z = x / y;
// z vlen 2, pjesa e plote e divizionit (ndarjes) midis 7 dhe 3
Lloji FLOAT dhe DOUBLE numra ne presje te levizshem, numra real, dhe mund te pèrdorenper te mbajtur te gjithe ato numra qe kane pjes te fraksionuara.Diferenca e ketyre llojeve qendron ne bit qe jane te rezervuar per raprezentimin qe permbajn, qe mund te reflektojn jo vetem ne rangun qe raprezentojn por edhe ne numrin ne shifer qe raprezentojn pas presjes. Do paraqesim nje cop te kodit per te kuptuar me shume.
double x = 7.0
double y = 2.0
double z;

z = x / y
// z vlen 3.5
Ne mesimin 9 po te shikoni shembujt praktik te kodit burim krijoni nje ide me te qart.
Numra me shenja dhe numra pa shenja.
Perdorimi i bit per te reprezantuar nje lloj te percaktuar vjen sipas SIGNED (me shenj) dhe UNSIGNED (pa shenj) Kjo per faktin nese nje tip eshte formuar me 8 bit me integer 144 qe si default eshte SIGNED do perdaroen shtat bit per te perfaqsuar numrin dhe nje bit per te prezantuar shenjen
01110010 // perfaqson , ne binar , integer 114
11110010 // duke nderruar bit ne te majte kemi si integer -114
Ndera po te kishim perdorur nje UNSIGNED INT, do kishim vlera pozitive, sepse edhe nje bit i percaktuar do perdorej per te paerfaqsuar numrin.
01110010 // prezanton , ne bit, integer 114
11110010 // prezanton , ne bit, integer 242
Pranojm se kemi N bit per te prezantuar nje numer, neseeshte SIGNED, vlerat e mundshme jane -2(n-1)+1 e 2(n-1), pra ne perfaqsimin e 8 bit do kishim vlera -127 dhe 128, kjo sepse midis numrave range duhet konsideruar edhe zero.
Ne rastin UNSIGNED vlerat jane pozitive dhe mund te marrin vlera nga 0 dhe 2n - 1, ndersa ne rastin 8 bit do kishim vlera nga 0 dhe 255

[iktuus]

Mesimi 12
Operatoret sherbejn neper programe per nxjerrjen e nje vlere te vecant nga fruti i transaksionit qe ndodh ne nje ose ne shume ndryshor ne kuadrin e programit. P.sh si (+) ne matematik qe sherben ne mbledhjen e dy numrave sherben edhe ne gjuhen e programit C ne te njejten menyr.
Natyrisht ka dallime, kryesisht operacionet e C jane themelore kane nje rezultat te mbaruar ne krahasim me matematiken qe mund te kete nje rezultat simbolik, mund te zbatohen edhe per vleren jo-numerike te variabileve.
Kemi te bejm me tre lloje operatoresh:
Operatoret aritmetik
Operatoret llogjik
Operator krahasues

[iktuus]

Operatoret aritmetik
Kemi pare operator te thjesht te detyres (=) dhe operatoret e ndarjes(/).Ketu do tregoj se si kryen detyrat e variabileve nga operatoret e tyre.Pervec ndarjes operatoret na lejojn te kryejm shuma(+)zbritje(-), shumzim(*)dhe ndarje me mbetje(%)
Nese perdorim numrat real (float ose double) operazioni i vetem qe nuk ka arsye te ekzistoj eshte ndarja me module, ndersa persa i perket operacionit me ndarje mund te permbaj pjes te pjesshme.Kemi te bejm me operator te tjer qe jane shume te rendesishem siperator me rritje(++)dhe operatoret me zbirjte(--)
Zbritja dhe rritja ndodhin gjithmon ne vleren e nje njesie mbi vleren e nje variabilve.
Shembuj:
int x = 2;
int y = 5;
int z = 9;
int k = 6;
// anesh, si komenti, vlera ne video
printf("%d n", x++); // 2
printf("%d n", ++y); // 6
printf("%d n", z--); // 9
printf("%d n", --k); // 5
Operatoret rrisin ose zbresin vlere e variabilve
x++
shembull:
x = x + 1;
Kemi nje form tjeter qe eshte precize por duhet shume kujdes ne perdorim pasi mund te jete e paqart ne perpunimin e kodit.
int y = 4;
y += 2; // i tashme vlen 6

int x = 3;
x *= y + 3; // x tashme vlen 27
// kjo sepse ekuivalon ne x=x*(y+3) dhe jo x=(x*y)+3

[iktuus]

Operatoret krahasues dhe operatoret llogjik
Krahasues
Operatoret krahasues na lejojn te kontrollojm kushte te caktuara si: barazia, pabarazia,nese nje objekt eshte me i madh se nje tjeter.
Shembull:
== barabart a == b
!= ndryshe a != b
< me e vogel a < b
> me e madhe a > b
<= vogel barabart a <= b
>= madhe barabart a >= b
Keto operator sherbejn kur kemi te bejm me deklarata te kushtezuara dhe unazore, nese gjendja e deklaratave verifikohet tregojn vertet, nese ndodh ndryshe tregojn fallso. Keta lloj operatoresh kan dy argumenta nuk ndodhen ne nje pozicion fiks por midis dy argumenteve.

Lllogjik
Edhe operatoret llogjik perdoren ne deklarata ne kushtezuara ose unazore, na lejojm te bejm AND (dhe) dhe OR (ose) midis dy operands.

&& and llogjik a && b
|| ose llogjik a || b
Keto operator tregojn 1 kur jane te vertet dhe 0 kur jan fallso, shprehja a || b merr vleren 1 nese a dhe b ka vleren nje, ndersa vlen zero nese te dy operatoret vlejn zero. Nese a && b marrin vleren zero nese a dhe b vlejn zero ne rast te kundert vlejn 1

[Kermilli]

Operatoret krahasues dhe operatoret llogjik
Krahasues
Operatoret krahasues na lejojn te kontrollojm kushte te caktuara si: barazia, pabarazia,nese nje objekt eshte me i madh se nje tjeter.
Shembull:
== barabart a == b
!= ndryshe a != b
< me e vogel a < b
> me e madhe a > b
<= vogel barabart a <= b
>= madhe barabart a >= b
Keto operator sherbejn kur kemi te bejm me deklarata te kushtezuara dhe unazore, nese gjendja e deklaratave verifikohet tregojn vertet, nese ndodh ndryshe tregojn fallso. Keta lloj operatoresh kan dy argumenta nuk ndodhen ne nje pozicion fiks por midis dy argumenteve.

Lllogjik
Edhe operatoret llogjik perdoren ne deklarata ne kushtezuara ose unazore, na lejojm te bejm AND (dhe) dhe OR (ose) midis dy operands.

&& and llogjik a && b
|| ose llogjik a || b
Keto operator tregojn 1 kur jane te vertet dhe 0 kur jan fallso, shprehja a || b merr vleren 1 nese a dhe b ka vleren nje, ndersa vlen zero nese te dy operatoret vlejn zero. Nese a && b marrin vleren zero nese a dhe b vlejn zero ne rast te kundert vlejn 1

Iktuus, Bravo per mesimet qe ke vene,jane shume te vlfshme sepse nuk eshte dhe shume e lehte ti gjesh keto mesime ne SHQIP