# Shkenca > Informatikë dhe Internet > Arti i programimit >  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 <front-end> 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 <stdio.h>

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 <iostream.h>

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

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 <stdio.h>

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 <stdio.h>, 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 <stdio.h>
12      #include <math.h>
13      #include <string.h>
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<i; 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<i_dim+1; 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
> ...


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

----------

