Përmbledhje detyrash në C++ (2)

Abstract

Kjo përmbledhje detyrash elektronike është përgatitur duke u bazuar në syllabusin e lëndës “Algoritmet dhe struktura e të dhënave” për vitin akademik 2012/2013 në Fakultetin e Inxhinierisë Elektrike dhe Kompjuterike të Universitetit të Prishtinës. Përmbledhja, në rend të parë, do t’ju shërbejë studentëve të këtij fakulteti, por gjithsesi që mund të jetë ndihmesë edhe për të tjerët.
Dua të shpreh mirënjohjen për studentët e Fakultetit të Inxhinierisë Elektrike dhe Kompjuterike të Universitetit të Prishtinës të cilët kanë ndjekur ushtrimet në Algoritmet dhe struktura e të dhënave gjatë semestrit veror (2012/2013). Me një pjesë prej tyre pata fatin të mbaj ushtrimet bashkërisht (grupet 1a’’, 4a’ dhe 4a’’), prandaj i falënderoj për sugjerimet dhe reagimet pozitive që kanë bërë, si në takimet e përbashkëta e po ashtu edhe përmes emailit.

Full text

Përmbledhe detyrash në C++ (2)
Vehbi Neziri
Ramadan Dervishi
Prishtinë, 2013

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
1
UNIVERSITETI I PRISHTINËS
Fakulteti i Inxhinierisë Elektrike dhe Kompjuterike
Vehbi Neziri
Ramadan Dervishi
Përmbledhje detyrash në C++ (2)
Prishtinë, 2013

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
2
Vehbi Neziri ka një përvojë të gjatë në programim, dhe tashmë ka
realizuar një mori projektesh kombëtare dhe ndërkombëtare në fushën e
programimit. Vehbiu mban titullin Master i Shkencave të Inxhinierisë
Kompjuterike dhe është asistent i angazhuar në Fakultetin e
Inxhinierisë Elektrike dhe Kompjuterike në Universitetin e Prishtinës.
Ramadan Dervishi ka një përvojë të gjatë në fushën e programimit, dhe
si autor dhe bashkautor ka realizuar një mori projektesh kombëtare dhe
ndërkombëtare që lidhen me teknologjinë e informacionit. Ramadani mban
titullin Master i Shkencave të Inxhinierisë Kompjuterike dhe është
mësimdhënës në kolegjin Riinvest.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
3
Na thoni mendimin tuaj!
Si lexues i kësaj përmbledhjeje, ju jeni kritik dhe komentues i rëndësishëm
për ne. Ne vlerësojmë mendimin tuaj dhe duam të dimë, se: çfarë kemi bërë
drejt, çfarë mund ta bëjmë më mirë, cilat janë fushat e interesit tuaj që ne
të publikojmë ose edhe sugjerime të tjera.
Komentet juaja janë të mirëpritura. Ju mund të na shkruani drejtpërdrejt në
adresën tonë të emailit duke na e bërë të qartë, se: çfarë kemi bërë mirë dhe
çfarë nuk ju pëlqen e që mund ta bëjmë më mirë në mënyrë që edicionet e
ardhshme të jenë më të mira.
Kontakti:
Vehbi Neziri: vehbi.neziri@uni-pr.edu
Ramadan Dervishi: dervishi@gmail.com

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
4
Kjo përmbledhje detyrash elektronike është përgatitur duke u bazuar në
syllabusin e lëndës “Algoritmet dhe struktura e të dhënave” për vitin
akademik 2012/2013 në Fakultetin e Inxhinierisë Elektrike dhe Kompjuterike të
Universitetit të Prishtinës. Përmbledhja, në rend të parë, do t’ju shërbejë
studentëve të këtij fakulteti, por gjithsesi që mund të jetë ndihmesë edhe
për të tjerët.
Dua të shpreh mirënjohjen për studentët e Fakultetit të Inxhinierisë
Elektrike dhe Kompjuterike të Universitetit të Prishtinës të cilët kanë
ndjekur ushtrimet në Algoritmet dhe struktura e të dhënave gjatë semestrit
veror (2012/2013). Me një pjesë prej tyre pata fatin të mbaj ushtrimet
bashkërisht (grupet 1a’’, 4a’ dhe 4a’’), prandaj i falënderoj për sugjerimet
dhe reagimet pozitive që kanë bërë, si në takimet e përbashkëta e po ashtu
edhe përmes emailit.
Vehbi Neziri
Prishtinë, maj 2013.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
5
Pasqyrë e shkurtër e secilit kapitull
Funksionet
Në këtë pjesë janë përfshirë shembuj të përgjithshëm të funksioneve, të
funksioneve të paracaktuara, të funksioneve të caktuara nga përdoruesi, të
funksioneve që kthejnë vlerë dhe atyre që nuk kthejnë vlerë, të funksioneve
inline, makrofunksioneve dhe funksioneve të mbingarkuara. .
Sinonimet
Në këtë pjesë ka shembuj përmes të cilëve tregohet se si mund të deklarohen
sinonimet për tipat e të dhënave.
Numërimet (enumerations)
Në këtë pjesë janë përfshirë shembuj të zgjidhur të detyrave me
grupime/numërime. Është treguar se si të përcaktohet dhe të shfrytëzohet një
grup, pastaj degëzimi i vlerave të numëruara, shoqërimi i vlerave të mënyrës
direkte, operimi me variabla të numëruara dhe të dhënat e numëruara në
funksione.
Strukturat
Në këtë pjesë tregohet se si të krijohet një strukturë e zakonshme, deklarimi
i variablave të tipit të strukturës, qasja në anëtarët e strukturës,
deklarimi dhe inicimi direkt i variablave. Tregohet dhe ka shembuj se si të
ruhen rezultatet e ndryshme në strukturë, si dhe shembuj me operatorët e
shoqërimit dhe ata relacionalë. Ka shembuj për strukturat e ndërthurura,
strukturat si parametra të funksioneve, fushat në struktura dhe fushat e
strukturave.
Klasat
Ky kapitull përmban shembuj të ndryshëm për klasat duke filluar prej krijimit
të një klase të zakonshme, deklarimin e objekteve, mënyrat e qasjes tek
anëtarët e klasës dhe format e përgjithshme të klasave. Po ashtu tregohet se
si të përdoren funksionet brenda klasave, tregohet dhe ka shembuj për
konstruktorët dhe destruktorët e klasës. Trashëgimia zë një vend të
rëndësishëm tek klasat, prandaj është trajtuar edhe trashëgimia, shfrytëzimi
i anëtarëve të mbrojtur ose protected, operatorët e shoqërimit, krahasimi i
objekteve, fushat brenda klasave dhe krijimi i fushave duke përdorur
objektet.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
6
Pointerët
Në këtë kapitull ka shembuj dhe ilustrime se si të deklarohet një pointer,
adresat e pointerëve, përdorimi dhe shoqërimi i vlerës së pointerit, operimet
e ndryshme me pointerë, operatori new dhe delete. Po ashtu ka shembuj për
fushat e pointerëve, pointerët në funksione, pointerët në anëtarët e
strukturave dhe klasave/
Referencat
Në këtë kapitull gjenden shembuj të ndryshëm se çka janë referencat, për çka
nevojiten dhe si përdoren. Tregohet për referencat e zakonshme, parametrat
referentë, si parametra formalë të funksioneve, fushat referente, parametrat
referentë brenda anëtarëve të strukturave dhe të klasave.
Fajllat
Ky kapitull ka shembuj të ndryshëm për punën me fajlla. Tregohet se çka janë
fajllat me qasje sekuenciale dhe çka janë fajllat me qasje direkte. Tregohet
se si të ruhen të dhënat e tipave të ndryshëm në këta fajlla dhe si të
lexohen të dhënat nga fajllat. Përmes shembujve është demonstruar se cilët
janë dhe si mund të hapet fajlli në mode të ndryshme të punës.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
7
Përmbajtja
Ambientet dhe veglat e punës ....................................................................................................... 11
Krijimi i një projekti të zbrazur në Visual C++ ......................................................... 11
Shtimi i një skedari të ri .cpp në projekt ............................................................... 14
Krijimi i një projekti të ri në CodeBlocks .................................................................... 16
1. Funksionet .................................................................................................................................. 20
1.1. Funksionet e paracaktuara ......................................................................................... 21
1.2. Funksionet e caktuara nga përdoruesi ................................................................. 24
1.2.1. Funksionet që kthejnë vlerë ................................................................................. 25
1.2.2. Funksionet që nuk kthejnë vlerë ........................................................................ 31
1.3. Funksionet Inline ........................................................................................................... 34
1.4. Makro funksionet ............................................................................................................. 36
1.5. Funksionet e mbingarkuara ......................................................................................... 37
2. Sinonimet .................................................................................................................................... 42
3. Numërimet (enumerations) ................................................................................................... 45
3.1. Përcaktimi dhe shfrytëzimi i grupit ................................................................... 45
3.2. Degëzimi përmes vlerave të numëruara ................................................................. 47
3.3. Disa variabla të numëruara të tipit të njëjtë ............................................. 51
3.4. Përcaktimi dhe deklarimi njëkohësisht ............................................................... 52
3.5. Shoqërimi direkt i vlerave ....................................................................................... 54
3.6. Operimi me variabla të numëruara dhe leximi .................................................. 55
3.7. Krijimi i disa grupeve njëkohësisht ................................................................... 56
3.8. Të dhënat e numëruara në nënprograme ................................................................. 57
4. Strukturat .................................................................................................................................. 60
4.1. Krijimi i strukturave të zakonshme ...................................................................... 60
4.2. Deklarimi i variablave të strukturës ................................................................. 61
4.3. Qasja në anëtarët e strukturës .............................................................................. 61
4.4. Deklarimi direkt i variablës së strukturës .................................................... 62
4.5. Inicimi direkt i variablave ..................................................................................... 63
4.6. Llogaritje me variablat e strukturës ................................................................. 65
4.7. Ruajtja e të dhënave në strukturë ........................................................................ 68
4.8. Disa variabla të një strukture .............................................................................. 69
4.9. Përdorimi i operacionit të shoqërimit ............................................................... 71
4.10. Përdorimi i operatorëve relacionalë ............................................................... 73
4.11. Disa struktura njëkohësisht ................................................................................. 74

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
8
4.12. Strukturat e ndërthurura ........................................................................................ 75
4.13. Strukturat si parametra të funksioneve ......................................................... 78
4.14. Disa nënprograme njëkohësisht ............................................................................. 80
4.15. Funksionet në komponentët e strukturave ....................................................... 82
4.15.1. Pa parametra formalë ............................................................................................ 82
4.15.2. Me parametra formalë ............................................................................................ 83
4.16. Fushat në struktura .................................................................................................. 86
4.17. Fushat e strukturave ................................................................................................ 88
5. Klasat ........................................................................................................................................... 89
5.1. Krijimi i klasave të zakonshme .............................................................................. 89
5.2. Deklarimi i objekteve .................................................................................................. 89
5.3. Qasja në komponentët e klasës ................................................................................. 90
5.4. Forma e përgjithshme e klasave .............................................................................. 92
5.5. Shfrytëzimi i funksioneve brenda klasës ........................................................... 94
5.6. Forma të tjera të inicimit të variablave ........................................................ 95
5.7. Shfrytëzimi i vlerave të variablave private .................................................. 98
5.8. Llogaritjet me variabla të klasës ...................................................................... 100
5.9. Shfrytëzimi i funksioneve brenda klasës ......................................................... 101
5.10. Konstruktorët .............................................................................................................. 108
5.10.1. Konstruktorët pa parametra formalë ............................................................ 108
5.10.2. Konstruktorët me parametra formalë ............................................................ 110
5.11. Llogaritjet brenda konstruktorëve .................................................................. 112
5.12. Disa konstruktorë njëkohësisht ........................................................................ 115
5.13. Destruktorët ................................................................................................................ 116
5.14. Trashëgimia .................................................................................................................. 117
5.15. Anëtarët statik të klasës ................................................................................... 123
5.16. Shfrytëzimi i anëtarëve të mbrojtur – protected ................................... 126
5.17. Shfrytëzimi i anëtarëve gjatë trashëgimisë .............................................. 128
5.18. Operatori i shoqërimit tek objektet ............................................................. 131
5.19. Krahasimi i objekteve të klasës ...................................................................... 132
5.20. Fushat brenda klasave ............................................................................................ 133
5.21. Krijimi i fushave duke përdor objektet ....................................................... 134
6. Pointerët .................................................................................................................................. 137
6.1. Deklarimi i pointerëve .............................................................................................. 137
6.2. Adresat e pointerëve .................................................................................................. 138
6.3. Përdorimi i vlerës së pointerit .......................................................................... 139
6.4. Shoqërimi i vlerave .................................................................................................... 140
6.5. Llogaritjet përmes pointerëve ............................................................................... 141
6.6. Operimi me pointerë .................................................................................................... 143

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
9
6.7. Operatori new dhe delete.......................................................................................... 146
6.8. Pointerët const ............................................................................................................. 148
6.9. Pointerët dhe fushat .................................................................................................. 149
6.10. Ponterët stringje ..................................................................................................... 153
6.11. Fusha pointerësh ....................................................................................................... 153
6.12. Pointerët si parametra të funksioneve ......................................................... 155
6.13. Pointerët në funksione .......................................................................................... 157
6.14. Pointerët në struktura .......................................................................................... 159
6.15. Pointerët në objekte .............................................................................................. 161
7. Referencat ................................................................................................................................ 164
7.1. Referencat e zakonshme .............................................................................................. 164
7.2. Parametrat referentë .................................................................................................. 165
7.3. Fushat referente ........................................................................................................... 168
7.4. Parametrat referentë brenda anëtarëve të strukturave ............................ 169
7.5. Parametrat referentë brenda anëtarëve të klasave ..................................... 172
7.6. Objektet referente ....................................................................................................... 174
8. Fajllat ....................................................................................................................................... 176
8.1. Fajllat me qasje sekuenciale ................................................................................. 176
8.2. Qasja të fajllat në unazë ....................................................................................... 177
8.3. Tekstet dhe numrat në fajlla ................................................................................. 179
8.4. Shkrimi dhe leximi i karaktereve ........................................................................ 182
8.5. Leximi i rreshtave ....................................................................................................... 183
8.6. Mode të hapjes së fajllave ..................................................................................... 184
8.7. Pozita në fajll ............................................................................................................. 186
8.8. Fajllat me qasje direkte.......................................................................................... 187
8.9. Vlerat e fushave në fajlla ..................................................................................... 189
8.10. Objektet në fajlla ................................................................................................... 191
9. Pyetje dhe shembuj vetë-testues .................................................................................. 196
9.1. Funksionet ........................................................................................................................ 196
9.2. Numerimet .......................................................................................................................... 198
9.3. Sinonimet .......................................................................................................................... 199
9.4. Strukturat ........................................................................................................................ 199
9.5. Klasat ................................................................................................................................. 201
9.6. Pointerët .......................................................................................................................... 203
9.7. Referencat ........................................................................................................................ 204
9.8. Fajllat ............................................................................................................................... 205
Literatura ............................................................................................................................................ 208

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
10

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
11
Ambientet dhe veglat e punës
Ekzistojnë vegla dhe programe të ndryshme që mundësojnë shkrimin e kodit
burimor dhe kompajlimin e tij. Në këtë përmbledhje do të tregohet se si të
punohet me Visual Studio.Net dhe me CodeBlocks.
Krijimi i një projekti të zbrazur në Visual C++
Për ta hapur një projekt të ri në Visual Studio C++, duhet ta keni të
instaluar ndonjërin nga versionet e Visual Studios.
Shembulli i mëposhtëm tregon se si krijohet një projekt i ri në Visual Studio
2012 (është e ngjashme edhe në versionet e tjera)
1. Klikoni në ikonën e Visual Studios (menyja Start ose desktop)
2. Pasi të keni klikuar ikonën e Visual Studios do të hapet Visual Studio si
në pamjen e mëposhtme.
3. Në këndin e lartë majtas klikoni në menynë File/New/Project ose përmes
shkurtesave Ctrl+Shift+N dhe do të shfaqet një dritare dialoguese.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
12
4. Në kutinë dialoguese duhet të zgjidhni Win32 Console Application për të
krijuar një aplikacion të bazuar në konzolë.
5. Pasi të keni zgjedhur Win32 Console Application, duhet të emërtoni
projektin me një emër (tek fusha Name) dhe më pas klikoni butonin OK.
6. Visual Studio do të krijojë projektin në shtegun i cili është zgjedhur në
fushën Location. Do të shfaqet një dritare e cila ju dëshiron
mirëseardhje. Klikoni butonin Next> për të vazhduar.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
13
7. Pasi keni klikuar Next do të shfaqet dritarja e mëposhtme. Në mënyrë që të
krijoni një projekt të zbrazur duhet të zgjidhni "Empty Project", në të
kundërtën Visual Studio do të shtojë skedarë (file) të panevojshëm për ju.
8. Klikoni butonin Finish për të përfunduar me krijimin e projektit. Tani
ambienti punues do të duket si në dritaren e mëposhtme.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
14
Shtimi i një skedari të ri .cpp në projekt
1. Klikoni me tastin e djathtë mbi Source Files dhe zgjidhni Add / New Item.
2. Programi do të ju pyes se çfarë skedari dëshironi të shtoni. Zgjidhni që
dëshironi të shtoni C++ File (.cpp) dhe më pas klikoni butonin Add.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
15
3. Tashmë siç shihet në dritaren e mëposhtme, kutitë dialoguese janë hequr
dhe ju jeni të lirë për të filluar programin e parë në C++.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
16
Krijimi i një projekti të ri në CodeBlocks
Për ta hapur një projekt të ri në CodeBlocks, duhet ta keni të instaluar
njërin nga versionet e programit. Më poshtë janë përshkruar hapat se si të
krijohet një projekt i ri.
1. Klikoni në ikonën e CodeBlocks (menyja Start ose desktop)
2. Pasi të keni klikuar ikonën e CodeBlocks do të hapet programi si në pamjen
e mëposhtme.
3. Në këndin e lartë majtas klikoni në menynë File/New/Project ose përmes
ikonës e cila gjendet në hapësirën punuese (Create a new Project) dhe do
të hapet dritarja dialoguese.
4. Në kutinë dialoguese, zgjidhet Console application për të krijuar një
aplikacion të bazuar në konzolë.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
17
9. Pasi është zgjedhur Console application, klikohet butoni butoni Go dhe do
të shfaqet dritarja e mëposhtme, e cila është një lloj magjistrati i cili
na ndihmon për të krijuar një projekt të ri. Nëse dëshirohet që kjo faqe
mos të paraqitet herave tjera klikohet opsioni “Skip thus page next time”.
10. Në dritaren e mëposhtme zgjedhet opsioni i dëshiruar, në rastin tonë
zgjidhet C++.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
18
11. Pasi të jetë zgjedhur C++, klikohet butoni Next dhe më pas do të
shfaqet dritarja në të cilën duhet të jepen emri i projektit dhe shtegu se
ku ku dëshirirojmë të ruhet projekti.
12. Pasi të jetë shkruar emri i projektit dhe të jetë zgjedhur shtegu duhet
të klikohet butoni Next. Do të hapet dritarja në të cilën ka mundësi të
zgjidhet kompajleri, të bëhet konfigurimi për modin Debug dhe Relase.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
19
13. Pas zgjedhjes së kompjalerit dhe konfigurimit klikohet butoni Finish
dhe tashmë projekti është krijuar.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
20
1. Funksionet
Funksioni është një grup i shprehjeve dhe komandave të ndryshme që kur
ekzekutohet kryen një punë të caktuar. Funksioni pas kryerjes së punës mund
të kthejë rezultat për punën e kryer apo edhe mund të mos kthejë rezultat
(void). Forma abstrakte e funksionit është dhënë në figurën 1.
Rezultati/dalja e një funksioni mund të jetë hyrje e një funksioni tjetër.
Përvojat tregojnë që mënyra më e mirë për të zhvilluar dhe mirëmbajtur
programe të mëdha është konstruktimi i tyre nga pjesë të vogla
(module/nënprograme). Figura 2 paraqet se si një program i shkruar i tëri në
funksionin main është ndarë në pjesë të vogla (funksione).
Përdorimi i funksioneve lehtëson dizajnin, ndërtimin, debugimin, zgjerimin,
modifikimin, ripërdorim dhe organizmin më të mirë të programit. Mënyra se si
funksioni main i thirr funksionet e tjera ka një analogji sikurse shefi me
punëtorët. Shefi (funksioni thirrës) i kërkon punëtorit (funksioni i thirrur)
për të kryer një punë dhe për të kthyer përgjigje kur të kryhet puna.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
21
Një nga arsyet kryesore për përdorimin e funksioneve është ndarja e programit
në punë të vogla dhe nëse diçka nuk shkon mirë, atëherë është më e lehtë të
identifikohet se ku është problemi.
1.1. Funksionet e paracaktuara
Funksionet paracaktuara janë funksione që janë ndërtuar në C + + për të kryer
disa operacione standarde. Funksionet e paracaktuara janë të grupuara në
librari të ndryshme të bazë të kategorive. Në C + +, koncepti i një funksioni
është i ngjashëm me atë të një funksioni në algjebër. Për shembull, çdo
funksion ka një emër dhe në varësi të vlerave të përcaktuara nga përdoruesi,
ai bën llogaritjet e duhura. Disa nga funksionet e paracaktuara në C++ janë
abs(x), pow(x,y), sin(x), cos(x), log(x) etj. Funksioni pow (x, y), llogarit
xy, që është, vlera e x e ngritur në fuqinë y. Për shembull, pow (2, 4) = 24
= 16.
1. Të shkruhet funksioni për llogaritjen e vlerës absolute për një vlerë të
caktuar.
#include <iostream>
#include <cmath>
using namespace std;
int main ()
{
cout<< "Vlera absolute e 3.1416 sht "
<< abs (3.1416)
<< endl;
cout<< "Vlera absolute e -2.89 sht "
<< abs (-2.89) << endl;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
22
2. Të shkruhet funksioni për llogaritjen e gjatësisë së hipotenuzës për
trekëndëshin kënddrejtë, nëse dihen gjatësia e brinjës a dhe brinjës b.
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
double a, b;
cout<<"Llogaritja e hipotenuzës për trekëndshin këndrejt\n";
cout << "Shëno gjatësinë e brinjës a:";
cin >> a ;
cout << "Shëno gjatësiën e brinjës b:";
cin >>b;
cout << "Gjatësia e hipotenuzës: " << hypot(a, b) << '\n';
system("pause");
return 0;
}
3. Të shkruhet programi për llogaritjen e sipërfaqes së rrethit duke përdorur
funksionin pow.
#include<iostream >
using namespace std;
int main()
{
float r, s;
const float pi=3.14159;
cout<< "Vlera e rrezes r = ";
cin >> r;
s = pi*pow(r,2); //pow(r,2) e ngrit ne katror rrezen r
cout<< "\nSiperfaqja e rrethit: s = "
<< s << endl;
return 0;
}
4. Të shkruhet programi për llogaritjen e rrënjës katrore të një numri të
dhënë, duke e përdorur funksionin sqrt.
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
double x = 25;
cout<<"Rrenja katrore e "<<x
<<" eshte " <<sqrt(x);
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
23
5. Të shkruhet programi për llogaritjen e sinusit të një këndi të caktuar
duke përdorur funksionin sin.
#include <iostream>
#include <cmath>
using namespace std;
#define PI 3.14159265
int main ()
{
double kendi;
kendi = 30.0;
cout<<"Sinusi i " << kendi
<< " shkalleve eshte "
<< sin (kendi*PI/180)
<<endl;
system("pause");
return 0;
}
6. Të shkruhet programi për llogaritjen e kosinusit të një këndi të caktuar
duke përdorur funksionin cos.
#include <iostream>
#include <cmath>
using namespace std;
#define PI 3.14159265
int main ()
{
double kendi;
kendi = 45.0;
cout<<"Kosinusi i " << kendi
<< " shkalleve është
<< cos (kendi*PI/180)
<<endl;
system("pause");
return 0;
}
7. Të shkruhet programi për llogaritjen e tangjentit për një vlerë të
caktuar, duke përdorur funksionin tan.
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
double x = 0.3333;
cout<<"Tangjenti i " <<x
<<" është " << tan(x);
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
24
8. Të shkruhet programi për llogaritjen e shprehjes y=ex duke përdorur
funksionin exp.
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
double x = 2.7;
cout<<"'e' e ngritur ne fuqinë 2.7 është "
<<exp(x)
<<endl;
system ("pause");
return 0;
}
9. Të shkruhet programi për llogaritjen e ln(x) për një vlerë të caktuar duke
e përdorur funksionin log.
#include <iostream>
#include <cmath>
using namespace std;
int main ()
{
double x=5.8;
cout<<"ln("<<x<<") = "
<<log (x);
system("pause");
return 0;
}
1.2. Funksionet e caktuara nga përdoruesi
C + + nuk ofron të gjitha funksionet e mundshme që i nevojiten përdoruesit,
sepse nevojat e secilit përdorues mund të jenë të ndryshme dhe specifike,
prandaj për këtë arsye duhet të shkruhen funksionet e caktuara nga
përdoruesi. Funksionet e caktuara nga përdoruesi, në C++ klasifikohen në dy
kategori:
 Funksione që kthejnë vlerë – këto funksione kanë një tip kthyes dhe
duke përdorur deklaratën return e kthejnë rezultatin e llojit të
caktuar të të dhënave.
 Funksione boshe (që nuk kthejnë vlerë) – këto funksione nuk kanë tip
kthyes të të dhënave. Këto funksione nuk e përdorin deklaratën return
për të kthyer rezultat.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
25
1.2.1. Funksionet që kthejnë vlerë
Sintaksa e deklarimit të një funksioni të caktuar nga përdoruesi dhe i cili
kthen rezultat është si më poshtë:
tipi emri_funksionit(tipi1 par1, tipi2 par3 ...)
{
deklarimet dhe shprehjet tjera_
}
 emri_funksionit – secili identifikator valid
 tipi – tipi i të dhënave për funksionin/rezultatin
 tipi1, tipi2 – tipi i të dhënave për parametrat
 par1, par2 – emrat e parametrave
Figura 4 paraqet deklarimin dhe implementimin e funksionit ngritjaNeFuqi i
cili parametrin e parë (baza) e ngrit në fuqi me parametrin e dytë
(eksponenti)
10. Të shkruhet programi i cili përmes funksionit max e kthen si rezultat
numrin më të madh në mes numrave x dhe y.
#include <iostream>
using namespace std;
double max(double x, double y)
{
double max;
if (x >= y)
max = x;
else
max = y;
return max;
}
int main()
{
double a,b;
a=42;
b=567;
cout<< "Numri më i madh është: "
<<max(a,b)
<<endl;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
26
11. Krijo funksionin hipotenuza i cili llogarit gjatësinë e hipotenuzës së
trekëndëshit kur dihet dihen gjatësitë e dy krahëve tjerë. Funksioni duhet
të ketë dy parametra hyrës të tipit double dhe të kthejë hipotenuzën të
tipit double.
#include <iostream>
#include <iomanip>
using namespace std;
double hypotenuza( double, double );
int main()
{
double brinja1, brinja2;
cout << setiosflags( ios::fixed | ios::showpoint );
cout << "Jep gjatsinë e brinjës b1= ";
cin >> brinja1;
cout << "Jep gjatsinë e brinjës b2= ";
cin >> brinja2;
cout << "Hypotenuza: " << setprecision(2)
<< hypotenuza( brinja1, brinja2 )
<< endl<<endl;
system("pause");
return 0;
}
double hypotenuza( double b1, double b2 )
{
return sqrt(b1 * b1 + b2 * b2 );
}
12. Të shkruhet funksioni shumëfishi i cili përcakton për çiftin e numrave
të plotë nëse numri i dytë është shumëfish i numrit të parë. Funksioni
duhet të ketë dy parametra të tipit të plotë dhe të kthejë si rezultat
true ose false.
#include <iostream>
using namespace std;
bool shumefishi( int, int );
int main()
{
int x, y;
for ( int i = 1; i <= 3; ++i )
{
cout << "Shtyp dy numra të plotë: ";
cin >> x >> y;
if ( shumefishi( x, y ) )
cout << y << " ëshët shumëfish i " << x << "\n\n";
else
cout << y << " nuk ëshët shumëfish i " << x << "\n\n";
}
cout << endl;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
27
bool shumefishi( int a, int b )
{
return !( b % a );
}
13. Të shkruhet funksioni sekondat i cili merr tre parametra të tipit int
(meqenëse koha është pozitive, parametrat dhe funksioni të jenë të
unsigned int). Funksioni të llogaris diferencën në mes dy kohëve të dhëna
dhe ta kthejë rezultatin në sekonda.
#include <iostream>
using namespace std;
unsigned int sekondat(unsigned, unsigned, unsigned );
int main()
{
unsigned ora, minuta, sekonda, temp;
cout << "Jep kohën e parë në formatin hh mm ss (p.sh 12 15 20): ";
cin >> ora >> minuta >> sekonda;
temp = sekondat( ora, minuta, sekonda );
cout << "Jep kohën e dytë në formatin hh mm ss (p.sh 12 15 20): ";
cin >> ora >> minuta >> sekonda;
cout << "Diferenca në mes kohës 1 dhe 2 është "
<< sekondat( ora, minuta, sekonda ) - temp
<< " sekonda" << endl;
system("pause");
return 0;
}
unsigned int sekondat( unsigned ora, unsigned min, unsigned sec)
{
return 3600 * ( ora >= 12 ? ora - 12 : ora ) + 60 * min + sec;
}
14. Të shkruhet funksioni perfekt i cili përcakton nëse parametri i tij
është numër perfekt. (Numri është perfekt nëse shuma e
faktorëve/plotpjesëtuesve të tij duke përfshirë edhe 1, por jo vetveten
është baras me numrin. p.sh 6=1+2+3). Duke shfrytëzuar funksionin perfekt
të shtypen të gjithë numrat perfekt nga 1 deri në 5000.
#include <iostream>
using namespace std;
bool perfekt(int numri )
{
int shuma = 1;
for ( int i = 2; i <= numri / 2; ++i )
if ( numri % i == 0 )
shuma += i;
return shuma == numri ? true : false;
}
int main()
{
cout << "Për numrat e plotë nga 1 deri 5000:\n";
for ( int j = 2; j <= 5000; ++j )

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
28
if ( perfekt( j ) )
cout << j << " është perfekt\n";
cout << endl;
system("pause");
return 0;
}
15. Të shkruhet funksioni distanca i cili llogarit distancën në mes dy
pikave. Funksioni të ketë 4 parametra të tipit double dhe si rezultat të
kthejë distancën e tipit double.
#include <iostream>
#include <iomanip>
using namespace std;
double distanca( double, double, double, double );
int main()
{
double x1, y1, x2, y2, dist;
cout << "Shtyp koordinatat e pikës 1: ";
cin >> x1 >> y1;
cout << "Shtyp koordinatat e pikës 2: ";
cin >> x2 >> y2;
dist = distanca( x1, y1, x2, y2 );
cout << setiosflags( ios::fixed | ios::showpoint )
<< "Distanca në mes ("
<< setprecision(2)
<< x1 << ", " << y1 << ") dhe ("
<< x2 << ", " << y2 << ") sht "
<< dist << endl;
system("pause");
return 0;
}
double distanca( double x1, double y1, double x2, double y2 )
{
return sqrt( pow( x1 - x2, 2 ) + pow( y1 - y2, 2 ) );
}
16. Të shkruhet funksioni shumezimi i cili gjeneron në mënyrë të
rastësishme dy numra nga 0-10 dhe pyet për prodhimin në mes e tyre. Përmes
një unaze të përsëritet procesi për më shumë numra dhe në fund të shtypet
se sa tentime kanë qenë të sakta dhe sa të pasakta.
#include <iostream>
#include <ctime>
using namespace std;
void shumezimi();
void mesazhi(bool rasti);
int main()
{
srand(time(0));
shumezimi();

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
29
system("pause");
return 0;
}
void shumezimi()
{
int x, y, pergjigja, sakte = 0, gabim = 0, m=5;
for ( int i = 1; i <= m; ++i )
{
x = rand() % 10; //numër i rastit 0-9
y = rand() % 10; //numër i rastit 0-9
cout << "Sa bejne: " << x << " x " << y << "? ";
cin >> pergjigja;
while (pergjigja != x * y )
{
++gabim;
cout << "Gabim. Provo përseri\n";
cout << "Sa bëjnë: " << x << " x " << y << "? ";
cin >> pergjigja;
}
++sakte;
cout << "Sakte. Urime!\n";
}
cout<< "Pyetje: "<<m
<< "\nTentime të sakta: " <<sakte
<< "\nTentime gabim: "<<gabim;
}
17. Të shkruhet programi i cili përmes funksionit aritmetika kryen veprimet
e mbledhjes, zbritjes, shumëzimit dhe pjesëtimit për dy numra të gjeneruar
në mënyrë të rastësishme. Përmes funksionit menyja të pyetet për veprimin
që duhet të kryhet (mbledhje, zbritje, shumëzim, pjesëtim apo kombinim i
rastësishëm). Veprimi të përsëritet disa herë dhe në fund të shtypet se sa
tentime kanë qenë të sakta dhe sa të pasakta.
#include <iostream>
#include <ctime>
using namespace std;
int menyja();
void aritmetika();
void mesazhi_sakte();
void mesazhi_gabim();
char v[]="\n------------------------------------------------------\n";
int main()
{
srand(time(0));
aritmetika();
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
30
int menyja()
{
int opsioni;
do
{
cout<< "Zgjidh një opsion nga 1-5."
<<v
<< "\nShtyp: 1 për mbledhje."
<< "\nShtyp: 2 për zbritje"
<< "\nShtyp: 3 për shumëzim."
<< "\nShtyp: 4 për pjesëtim."
<< "\nShtyp: 5 për kombinim të opsioneve nga 1 deri 4. "
<<v
<<"op = ";
cin >> opsioni;
} while (opsioni < 1 || opsioni > 5 );
return opsioni;
}
void mesazhi_gabim()
{
cout << "Gabim. Provo edhe njëherë.";
}
void mesazhi_sakte( void )
{
cout << "Mire. Vazhdo tutje.";
}
void aritmetika()
{
int x, y, pergjigjeLexuar, pergjigjeSakte, sakte = 0, gabim = 0, perseritje=5;
char shenja;
int zgjedhja = menyja();
for (int i = 1; i <= perseritje; ++i )
{
x = rand() % 10;
y = rand() % 10;
if (zgjedhja == 5) //nese zgjidhet opsioni 5 zgjidh ne menyre te rastit
{
zgjedhja = 1 + rand() % 4;
}
switch ( zgjedhja )
{
case 1: // mbledhja
shenja = '+';
pergjigjeSakte = x + y;
break;
case 2: // zbritja
shenja = '-';
pergjigjeSakte = x - y;
break;
case 3: // shumezimi
shenja = '*';
pergjigjeSakte = x * y;
break;
case 4: // pjesetimi

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
31
shenja = '/';
if (y == 0)
{
y = 1; // pjesetimi me zero
pergjigjeSakte = x / y;
}
else
{
x *= y;
pergjigjeSakte = x / y;
}
break;
}
cout << "\nSa bëjnë: " << x << " " << shenja << " " << y << "? ";
cin >> pergjigjeLexuar;
while (pergjigjeLexuar != pergjigjeSakte)
{
++gabim;
mesazhi_gabim();
cout << "\nSa bëjnë: " << x << " x " << y << "? ";
cin >> pergjigjeLexuar;
}
++sakte;
mesazhi_sakte();
}
cout<< v
<<"\nPyetje: "<<perseritje
<< "\nTentime të sakta: " <<sakte
<< "\nTentime gabim: "<<gabim <<endl;
}
1.2.2. Funksionet që nuk kthejnë vlerë
Funksionet boshe (që nuk kthejnë vlerë) dhe funksionet që kthejnë vlerë e
kanë strukturën e njëjtë. Të dy llojet e kanë edhe kokën (heading) dhe trupin
(body). Funksionet boshe nuk kthejnë rezultat, por vetëm e kryejnë një punë
të caktuar dhe nuk e përdorin deklaratën return. Megjithatë edhe tek këto
funksione mund të përdoret return pa ndonjë vlerë kthyese. Për të deklaruar
një funksion bosh përdoret fjala void para emrit të funksionit, për tipin
kthyes të të dhënave. Sintaksa e deklarimit është si në vijim:
void emri_funksionit(tipi1 par1, tipi2 par3 ...)
{
deklarimet dhe shprehjet tjera_
}
Edhe funksionet që kthejnë vlerë edhe funksionet boshe, mund të kenë apo mos
të kenë parametra formalë. Figura 5 paraqet deklarimin dhe implementimin e
funksionit printoNumrin i cili shtyp vlerën e parametrit.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
32
18. Të shkruhet funksioni void shtyp_numrin i cili shtyp vlerën e
parametrit të tij.
#include <iostream>
using namespace std;
void shtyp_numrin(int numri)
{
cout << numri << '\n';
}
int main()
{
cout<<"Thirja e funksionit void\n";
shtyp_numrin(10);
system("pause");
return 0;
}
19. Të shkruhet funksioni void max i cili gjen dhe shtyp numrin më të madh
nga dy parametrat formal të tipit double.
#include <iostream>
using namespace std;
void max(double x, double y)
{
double m;
if (x >= y)
m = x;
else
m = y;
cout<<"Numri më madh është"
<<m;
}
int main()
{
double a=42,b=55;
max(a,b); //thirrja e funksionit void
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
33
20. Të shkruhet funksioni void shtypja i cili shtyp numrat e plotë nga 1
deri në n. Funksioni le ta ketë një parametër formal të tipit int.
#include <iostream>
using namespace std;
void shtypja(int); //prototipi i funksionit
int main ()
{
shtypja(5); //thirrja e funksionit
system("pause");
return 0;
}
void shtypja (int n)
{
cout << "Shtypa e numrave nga 1 deri n렢 <<n<< endl;
for (int i=1;i<=n;i++)
cout<<i<<endl;
}
21. Të shkruhet programi për printimin e numrave të thjeshtë nga 1 deri në
n duke përdorur funksionin i cili nuk kthen rezultat (void).
#include <iostream>
using namespace std;
void numriThjeshte(int numri)
{
int i,j,kontrolli;
cout<<"Numrat e thjesht려eri "<<numri <<"\n";
for(i = 1; i <= numri; i++)
{
kontrolli = 0;
for(j = i-1; j > 1 ; j--)
if(i%j == 0)
{
kontrolli++;
break;
}
if(kontrolli == 0)
{
cout.width(3);
cout<<i;
}
}
cout<<"\n";
}
int main()
{
numriThjeshte(50);
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
34
1.3. Funksionet Inline
Janë funksione në të cilin kompajleri kërkon që të kryhet një zgjerim, pra
kodi i funksionit e zëvendëson vendin ku thirret funksioni.
Figura 5 paraqet thirrjen e funksionit inline, kurse figura 6 paraqet
zgjerimin e kodit të pjesa ku thirret funksioni.
22. Të shkruhet programi i cili përdor një funksion inline të quajtur
sipRrethi i cili e llogarit sipërfaqen e rrethit.
#include <iostream>
using namespace std;
double const pi = 3.14159;
inline double sipRrethi(double r)
{
return pi * r * r;
}
int main()
{
double rrezja;
cout << "Shtyp rrezen e rrethit: ";
cin >> rrezja;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
35
cout<< "Siperfaqja e rrethit është "
<< sipRrethi(rrezja) << endl;
system("pause");
return 0;
}
23. Të shkruhet programi i cili përdor një funksion inline të quajtur
vellKubi i cili e llogarit vëllimin e kubit.
#include <iostream>
using namespace std;
inline double vellKubi(double brinja )
{
return brinja * brinja * brinja;
}
int main()
{
double brinja;
cout << "Shëno gjatësinë e brinjës së kubit: ";
cin >> brinja;
cout << "Vëllimi i kubit është: "
<< vellKubi(brinja) << endl;
system("pause");
return 0;
}
24. Të shkruhet funksioni inline max i cili kthen vlerën më të madhe në mes
dy vlerave të dhëna.
#include <iostream>
using namespace std;
inline int max(int a, int b)
{
return a > b ? a : b;
}
int main( void)
{
int x1, x2;
cout<<"Jep dy vlera ";
cin>>x1>>x2;
cout<< "Maksimumi i numrit "
<<x1<<" dhe " << x2
<< " është "
<<max(x1, x2) << endl;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
36
25. Të shkruhet programi i cili shkronjën e vogël e kthen në shkronjë të
madhe. Kjo të realizohet duke përdorur operatorin e kushtëzuar ? dhe
funksionin inline.
#include <iostream>
using namespace std;
inline char shkronja_madhe( char a )
{
return ((a >= 'a' && a <= 'z') ? a-('a'-'A') : a );
}
int main()
{
cout<<("Shëno një shkronjë: ");
char shkronja;
cin>> shkronja;
shkronja= shkronja_madhe( shkronja);
cout<<"Shkronja e madhe: "
<<shkronja
<<endl;
system("pause");
return 0;
}
1.4. Makro funksionet
Më së shpeshti përdoren për të deklaruar konstante të cilat mund të përdoren
në vend të konstanteve të deklaruara dhe variablave. Për deklarimin e makro-
funksioneve përdoret direktiva #define. Disa shembuj të deklarimit të makro-
funksioneve janë dhënë në figurën 7.
Avantazhi i makro-funksioneve është se interpretohen gjatë kohës së
kompajlimit. Janë jashtëzakonisht të dobishme kur blloqe të njëjta të kodit
duhet të ekzekutohen disa herë.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
37
26. Të shkruhet makro funksioni max i cili kthen vlerën më të madhe në mes
dy vlerave të dhëna.
#include <iostream>
using namespace std;
#define max (a, b) ((a < b)? a: b)
int main( void)
{
int x1, x2;
cout<<"Jep dy vlera ";
cin>>x1>>x2;
cout<< "Maksimumi i numrit "
<<x1<<" dhe " << x2
<< " është "
<<max(x1, x2) << endl;
system("pause");
return 0;
}
27. Të krijohet makroja e funksionit llogaritja e cila llogarit shprehjen e
mëposhtme, nëse dihet vlera e x-it.
#include<iostream>
using namespace std;
#define llogaritjaY(x) ((x>0) ? (6*x-2):(2*x+6))
int main()
{
double y=0, x=5;
y=llogaritjaY(x);
cout<< "\nVlera e llogaritur për x="
<<x
<<" është y="
<<y
<< "\n\n";
system("pause");
return 0;
}
1.5. Funksionet e mbingarkuara
Funksionet e mbingarkuara janë dy ose më shumë funksione me të njëjtin emër,
por me parametra të ndryshëm për nga numri i parametrave ose tipi i të
dhënave të parametrave. C++ lejon disa funksione me emër të njëjtë deri sa e
kanë nënshkrimin e ndryshëm. Kompajleri i C++ zgjedh funksionin e duhur për
ta thirrur, duke u bazuar në numrin, tipin dhe rendin e parametrave.
Zakonisht funksionet e mbingarkuara përdoren për të kryer punë të ngjashme
por me tipa të ndryshëm të të dhënave.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
38
Një shembull i funksionit të mbingarkuar shihet në figurën e mëposhtme.
28. Të shkruhet programi i cili llogarit sipërfaqen e rrethit dhe
drejtkëndëshit përmes funksionit të mbingarkuar siperfaqja().
#include<iostream>
using namespace std;
#define pi 3.14159265359
void siperfaqja(int r)
{
cout<<"Sipërfaqja e rrethit:"<<pi*r*r;
}
void siperfaqja(int a,int b)
{
cout<<"Sipërfaqja e drejtkëndëshit:"<<a*b;
}
int main()
{
int a,b,r;
cout<<"Rrezja r= ";
cin>>r;
siperfaqja(r);
cout<<"\nKrahet a=?b=?";
cin>>a>>b;
siperfaqja(a,b);
cout<<endl;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
39
29. Të shkruhet programi për llogaritjen e shprehjes së mëposhtme përmes
funksionit të mbingarkuar shuma().
#include <iostream>
using namespace std;
double shuma(int n)
{
double s;
int i; s=0;
for (i=0;i<=n;i++)
s=s+(4*i+2);
return s;
}
double shuma(int n,double x)
{
double s;
int i; s=0;
for (i=3;i<=2*n;i++)
s=s+(3*i-2*x);
return s;
}
int main()
{
double x,y1,y2;
int n=10;
cout << "Vlera x=";
cin >> x;
cout << "\nVlerat e llogaritura\n\n";
y1=shuma(n);
cout << " y=" << y1;
y2=pow(x+3,2)+shuma(n,x);
cout << "\n z="<< y2
<< "\n\n";
system("pause");
return 0;
}
30. Të shkruhen 2 funksione me emrin maksimumi(). Njëri funksion të gjejë
dhe ta shtyp numrin më të madh në vektorin A(m), kurse funksioni tjetër
numrin më të madh në matricën B(m,m). Vektori dhe matrica gjatë deklarimit
të iniciohen me vlera fillestare.
#include <iostream>
using namespace std;
const int m=3;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
40
int maksimumi(int v[], int m)
{
int max = v[0];
for (int i = 1; i < m; i++)
if (v[i] > max)
max = v[i];
return max;
}
int maksimumi(int a[m][m], int m)
{
int max=a[0][0];
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++)
if (max < a[i][j])
max = a[i][j];
return max;
}
int main()
{
int a[m] = {3,-7,8};
int Z[m][m] = {{3,7,4},{-6,2,-3},{6,1,5}};
cout<<"Vlera maksimale e vektorit: "<< maksimumi(a,m);
cout<<"\nVlera maksimale e matricës: "<< maksimumi(Z,m);
cout<<endl;
system("pause");
return 0;
}
31. Të shkruhen 3 funksione me emrin siperfaqja() të cilat llogarisin
sipërfaqen e kubit, sferës dhe konit. Funksionet të thirren për vlera të
lexuara përmes tastierës.
#include<iostream>
using namespace std;
#define pi 3.14159265359
void siperfaqja(int a)
{
cout<<"Sipërfaqja e kubit:"<<6*a*a;
}
void siperfaqja(double r)
{
cout<<"Sipërfaqja e sferes:"<<4*pi*r*r;
}
void siperfaqja(double r,double h)
{
cout<<"Sipërfaqja e konit:"<<pi*r*sqrt(r*r+h*h);
}
int main()
{
int a=10;
double r=12.56,h=8.26;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
41
cout<<"Llogaritja e sipërfaqes se kubit, sferës dhe konit\n";
siperfaqja(a);
cout<<endl;
siperfaqja(r);
cout<<endl;
siperfaqja(r,h);
cout<<endl;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
42
2. Sinonimet
Për tipat e të dhënave mund të krijohen sinonime ose pseudonime duke përdorur
deklaratën typedef. Sintaksa e krijimit të sinonimeve është dhënë në figurën
9.
typedef nuk krijon tip të ri të dhënave, por krijon një sinonim për tipin
ekzistues. Sinonimet mund të jenë lokale dhe globale.
32. Të shkruhet programi për llogaritjen e faktorielit (n!) duke përdorur
funksionin faktorieli. Për tipin int të krijohet sinonimi plote, kurse për
double të krijohet sinonimi decimal.
#include <iostream>
using namespace std;
double faktorieli(int n)
{
typedef int plote; //sinonim lokal
typedef double decimal; //sinonim lokal
plote i;
decimal F=1;
for (i=1;i<=n;i++)
F=F*i;
return F;
}
int main()
{
typedef int plote; //sinonim lokal
typedef double decimal; //sinonim lokal
plote n=0;
decimal fakt;
cout<<"Vlera n = ";
cin>>n;
fakt = faktorieli(n);
cout<< "Faktorieli F= "
<< fakt<<"\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
43
33. Të shkruhet programi i cili përmes funksionit vektori() e llogarit
prodhimin e anëtarëve negativ të vektorit A(m). Për tipin int dhe double
të krijohen sinonimet globale, plote respektivisht decimal.
#include <iostream>
using namespace std;
typedef int plote; //sinonim global
typedef double decimal; //sinonim global
decimal vektori(decimal v[], plote m)
{
decimal p=1;
for (int i = 0; i < m; i++)
if (v[i] < 0)
{
p=p* v[i];
}
return p;
}
int main()
{
const plote m=8;
plote i;
decimal A[m]={-12,3,22,6,-8,33,-18,4};
cout<<"Prodhimi i antarve negativ S= "
<< vektori(A,m)
<<endl;
system("pause");
return 0;
}
34. Të shkruhet programi i cili përmban një funksion të mbingarkuar i cili
shtyp vlerat e secilit parametër. Njëri funksion të ketë dy, kurse tjetri
tre parametra të tipit të çfarëdoshëm. Për tipat e të dhënave të krijohen
sinonime.
#include<iostream>
using namespace std;
typedef int plote;
typedef double decimal;
void funMbingarkuar(plote a, plote b, decimal c)
{
cout<<"\nHyrja në funksionin 1"
<<"\nVlera e a="<<a
<<"\nVlera e b="<<b
<<"\nVlera e c="<<c
<<"\nDalja nga funksioni 1"
<<endl;
}
void funMbingarkuar(plote a, decimal b, decimal c)
{
cout<<"\nHyrja në funksionin 2"
<<"\nVlera e a="<<a

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
44
<<"\nVlera e b="<<b
<<"\nVlera e c="<<c
<<"\nDalja nga funksioni 2"
<<endl;
}
int main()
{
funMbingarkuar(2,5,11);
funMbingarkuar(2,5.5,11.5);
funMbingarkuar(2,5,11.5);
cout<<endl;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
45
3. Numërimet (enumerations)
Numërimet janë lista të konstanteve me të gjitha vlerat e mundshme.
Konstantet e emëruara ruhen në memorie si numra të plotë (integer) duke
filluar nga 0, 1 e kështu me radhë, nëse nuk përcaktohet ndryshe.
3.1. Përcaktimi dhe shfrytëzimi i grupit
Një grup përcaktohet duke e shfrytëzuar komandën enum. Anëtarët e grupit
quhen edhe numërues (ang. enumerator). Sintaksa për deklarimin e një grupi të
numëruar është:
enum emri_grupit {vlera1, vlera2, ...};
 enum - fjala çelës
 emir_grupit – emri i grupit të numëruar
 vlera1, vlera2… emrat e konstanteve të numëruara
Në figurën 11 është dhënë një shembull i deklarimit të grupit dhe shpjegimi
për sintaksën e grupit.
Sintaksa e deklarimit të variablave të grupit është g v;
g – emri i grupit
v – variabla e deklaruar e grupit
Në figurën 12 është dhënë grupi sportet. Më pas është deklaruar variabla e
grupit dhe është iniciuar me njërën nga vlerat e numëruara të grupit.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
46
35. Të krijohet grupi shtetet i cili përmban anëtarët: Kosova, Shqiperia,
Maqedonia, Gjermania dhe Suedia. Më pas të deklarohet një variabël e tipit
shtetet dhe të shtypet vlera e paracaktuar (default) për Gjermaninë.
#include <iostream>
using namespace std;
enum shtetet
{
Kosova,
Shqiperia,
Maqedonia,
Gjermania,
Suedia
};
int main()
{
shtetet shteti;
shteti = Gjermania;
cout << "\nGjermania e ka vlerën e paracaktuar (default) = "
<< shteti <<endl ;
system("pause");
return 0;
}
36. Të shkruhet programi në të cilin është i deklaruar një grup me emrin
veturat. Grupi të përmbajë disa lloje të veturave dhe më pas të shtypet
vlera e paracaktuar për veturën e preferuar.
#include <iostream>
using namespace std;
enum veturat
{
bmw,
mercedes,
fiat,
audi,
kia,
mazda,
nissan,
toyota
};
int main()
{
veturat veturaIme;
veturaIme = audi;
cout << "\nVetura e preferuare ka vleren e paracaktuar (default) = "
<< veturaIme <<endl ;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
47
37. Të shkruhet programi në të cilin është i deklaruar një grup me emrin
stinet i cili përmban katër stinët e vitit. Më pas të shtypen vlerat e
nënkuptuara (default) për secilën stinë të vitit.
#include <iostream>
using namespace std;
enum stinet
{
pranvera,
vera,
vjeshta,
dimri
};
int main()
{
cout << "\nStinet e vitit janë:\n"
<< pranvera << ". Pranvera\n "
<< vera << ". Vera\n"
<< vjeshta << ". Vjeshta\n"
<< dimri << ". Dimri \n";
system("pause");
return 0;
}
3.2. Degëzimi përmes vlerave të numëruara
Vlerat e numëruara mund të shfrytëzohen për realizimin e degëzimeve duke
përdorur komandën if, ose switch.
38. Nëse është dhënë grupi gjendjet, të shkruhet programi në të cilin
deklarohet variabla e numëruar nota dhe përmes komandës if të shtypet
rezultati.
enum gjendjet
{
dobet,
mire,
shumemire,
shkelqyeshem
};
#include<iostream>
using namespace std;
enum gjendjet
{
dobet,
mire,
shumemire,
shkelqyeshem
};
int main()

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
48
{
gjendjet nota;
nota=shkelqyeshem;
if (nota==dobet)
cout << "\nKeni arritur sukses t dobët\n";
else if (nota==mire)
cout << "\nKeni arritur sukses të mirë\n";
else if (nota==shumemire)
cout << "\nKeni arritur sukses shumë të mirë\n";
else if (nota==shkelqyeshem)
cout << "\nKeni arritur sukses të shkëlqyeshëm\n";
system("pause");
return 0;
}
39. Nëse është dhënë grupi java, të shkruhet programi i cili përmes
komandës switch dhe variablës së numëruar dita, shtyp rezultatin për ditën
e zgjedhur.
enum java
{
hene,
marte,
merkure,
enjte,
premte,
shtune,
diel
};
#include <iostream>
using namespace std;
enum java
{
hene,
marte,
merkure,
enjte,
premte,
shtune,
diel
};
int main()
{
java dita;
dita=enjte;
cout << "\nDita që u zgjodh është dita e ";
switch (dita)
{
case hene: cout << "hëne";break;
case marte: cout << "marte";break;
case merkure: cout << "mërkure";break;
case enjte: cout << "ënjte";break;
case premte: cout << "premte";break;
case shtune: cout << "shtune";break;
case diel: cout << "diel";break;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
49
cout << "\n\n";
system("pause");
return 0;
}
40. Të shkruhet programi dhe të deklarohet një grup me emrin nota i cili
si anëtarë ka notat nga pesë deri në dhjetë. Secilit anëtar të i
shoqërohet vlera numerike. Më pas të shtypet rezultati për notat në
algoritme, programim dhe matematikë si dhe të tregohet se në cilën lëndë
është nota më e lartë.
#include <iostream>
using namespace std;
enum nota
{
pese=5,
gjashte=6,
shtate=7,
tete=8,
nente=9,
dhjete=10
}algoritme, matematike, programim;
int main()
{
matematike=shtate;
programim=tete;
algoritme=nente;
cout << "\nNota në Matematikë është "
<< matematike
<< "\nNota në Algoritme është "
<< algoritme
<< "\nNota në Programim është "
<< programim
<< "\n";
if (algoritme >programim && algoritme>matematike)
cout << "\nNota më e lart është n Algoritme";
else if (programim >algoritme && programim>matematike)
cout << "\nNota më e lartë është në Programim";
else
cout << "\nNota më e lartë është në Matematikë";
cout << "\n\n";
system("pause");
return 0;
}
41. Të shkruhet programi dhe të deklarohet një grup me emrin nota i cili
si anëtarë ka notat nga pesë deri në dhjetë. Secilit anëtar të i
shoqërohet vlera numerike. Vlera fillestare për notën në programim të
lexohet nga tastiera. Përmes komandës if të shtypet nota e lexuar nga
tastiera, më pas të rritet nota për 1 dhe të shtypet përsëri.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
50
#include <iostream>
using namespace std;
enum nota
{
pese=5,
gjashte=6,
shtate=7,
tete=8,
nente=9,
dhjete=10
}programim;
int main()
{
int vlera;
cout << "\nSa është nota në Programim: ";
cin >> vlera;
cout << "\nNota në Programim është ";
if (vlera=6)
{
programim=gjashte;
cout << programim;
}
else if (vlera=7)
{
programim=shtate;
cout << programim;
}
else if (vlera=8)
{
programim=tete;
cout << programim;
}
else if (vlera=9)
{
programim=nente;
cout << programim;
}
else if (vlera=10)
{
programim=dhjete;
cout << programim;
}
else
{
cout << "Jo kaluese";
}
programim=static_cast<nota>(programim+1);
cout<< "\nNota në Programim është rritur për 1 "
<<"dhe tani është:" << programim
<< "\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
51
42. Të shkruhet programi në të cilin deklarohen dy grupe me emrin
ekzekutuar dhe funksionimi. Grupi ekzekutuar të përmbajë gjendjet: PO dhe
JO; kurse grupi funksionimi të përmbajë: rregull dhe gabim. Duke përdorur
komandën if të kontrollohet se a është ekzekutuar programi dhe a është në
rregull apo ka gabime.
#include <iostream>
using namespace std;
enum ekzekutuar
{
PO,
JO
} ekz;
enum funksionimi
{
rregull,
gabim
} fun;
int main()
{
ekz=PO;
fun=rregull;
if (ekz ==PO && fun== rregull)
{
cout<<"Programi sht ekzekutuar dhe po funksionon n rregull\n";
}
else if (ekz ==PO && fun== gabim)
{
cout<<"Programi sht ekzekutuar, por nuk po funksionon n rregull\n";
}
else if (ekz ==JO && fun== rregull)
{
cout<<"Programi nuk sht ekzekutuar, dhe po funksionon n rregull\n";
}
else if (ekz ==JO && fun== gabim)
{
cout<<"Programi nuk sht ekzekutuar, prandaj nuk po funksionon n
rregull\n";
}
system("pause");
return 0;
}
3.3. Disa variabla të numëruara të tipit të
njëjtë
Sikurse të variablat e tipave standard, brenda një programi mund të
deklarohen edhe disa variabla të numëruara të tipit të njëjtë. Sintaksa e
deklarimit të variablave është:

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
52
g v1, v2, v3, . . . ;
g – emri i grupit
v1, v2, v3 ...- emrat e variablave të grupit
43. Të shkruhet programi në të cilin deklarohet grupi java me ditët e
javës. Përmes variablave punuese dhe pushuese, të tregohet se me cilin
numër fillojnë ditët e punës dhe me cilin numër fillojnë ditët e pushimit
(fundjavës).
#include <iostream>
using namespace std;
enum java
{
hene,
marte,
merkure,
enjte,
premte,
shtune,
diel
};
int main()
{
java punuese;
java pushuese;
punuese=hene;
pushuese=shtune;
cout << "\nDitët e punës fillojnë me numrin: "
<< punuese
<< "\n\nDitët e pushimit fillojnë me numrin: "
<< pushuese
<< "\n\n";
system("pause");
return 0;
}
3.4. Përcaktimi dhe deklarimi njëkohësisht
Gjatë përcaktimit të grupit me të dhëna të numëruara, mund të bëhet edhe
deklarimi i variablës përkatëse. Në figurën 13 shihet sintaksa dhe një
shembull i përcaktimit dhe deklarimit të variablës njëkohësisht. Në këtë
figurë emri i variablës së grupit g është var.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
53
44. Të shkruhet programi në të cilin përcaktohet grupi viti me vlera stinët
e vitit. Gjatë përcaktimit të deklarohet variabla stina. Variabla të
iniciohet në funksionin main dhe me pas në varësi të vlerës së iniciuar të
shfaqet mesazhi i formuar "Stina e …".
#include <iostream>
using namespace std;
enum viti
{
pranvera,
vera,
vjeshta,
dimri
}
stina;
int main()
{
stina=pranvera;
if (stina==pranvera)
cout << "\nStina e pranverës";
else if (stina==vera)
cout << "\nStina e verës";
else if (stina==vjeshta)
cout << "\nStina e vjeshtës";
else
cout << "\nStina e dimrit";
cout << "\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
54
3.5. Shoqërimi direkt i vlerave
Gjatë përcaktimit të grupit, mund të bëhet edhe shoqërimi me vlera të
caktuara për anëtarët e grupit.
45. Të shkruhet programi dhe të deklarohet një grup me emrin nota i cili
si anëtarë ka notat nga pesë deri në dhjetë. Secilit anëtar të i
shoqërohet vlera numerike. Më pas të shtypet rezultati për notat në
algoritme, programim dhe matematikë.
#include <iostream>
using namespace std;
enum nota
{
pese=5,
gjashte=6,
shtate=7,
tete=8,
nente=9,
dhjete=10
}algoritme, matematike, programim;
int main()
{
matematike=shtate;
programim=tete;
algoritme=nente;
cout << "\nNota në Matematikë është "
<< matematike
<< "\nNota në Algoritme është "
<< algoritme
<< "\nNota në Programim është "
<< programim
<< "\n";
cout << "\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
55
3.6. Operimi me variabla të numëruara dhe leximi
Variabla e numëruar mund t'i shoqërohet një variable tjetër të numëruar,
përmes operatorit të barazimit (=), p.sh v1=v2. Për të shfrytëzuar variablat
e numëruara në shprehje të ndryshme duhet të bëhet konvertimi eksplicit
përmes static_cast. Nëse është deklaruar grupi nota dhe variabla e grupit
algoritme:
Nëse variabla algoritme është iniciuar me njërën nga vlerat dhe më pas
dëshirohet të rritet vlera për dy, atëherë kjo bëhet përmes konvertimit si më
poshtë:
Vlerat e të dhënave të numëruara lexohen në mënyrë indirekte përmes
variablave.
46. Të shkruhet programi dhe të deklarohet një grup me emrin nota i cili
si anëtarë ka notat nga pesë deri në dhjetë. Secilit anëtar të i
shoqërohet vlera numerike. Vlera fillestare për notën në algoritme të
lexohet nga tastiera dhe përmes komandës switch të shtypet nota, më pas të
rritet nota për 2 dhe të shtypet përsëri.
#include <iostream>
using namespace std;
enum nota
{
pese=5,
gjashte=6,
shtate=7,
tete=8,
nente=9,
dhjete=10
}algoritme;
int main46()
{
int vlera;
cout << "\nSa është nota në Algoritme: ";
cin >> vlera;
cout << "\nNota në Algoritme është ";
switch (vlera)
{
case 6:
algoritme=gjashte;
cout << algoritme;break;
case 7:
algoritme=static_cast<nota>(algoritme+2);
enum nota
{
//...
}algoritme;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
56
algoritme=shtate;
cout << algoritme;break;
case 8:
algoritme=tete;
cout << algoritme;break;
case 9:
algoritme=nente;
cout << algoritme;break;
b 10:
algoritme=dhjete;
cout << algoritme;break;
default:
cout << "Jo kaluese";break;
}
algoritme=static_cast<nota>(algoritme+2);
cout<< "\nNota n Algoritme është rritur për 2 "
<<"dhe tani sht:" << algoritme
<< "\n";
system("pause");
return 0;
}
3.7. Krijimi i disa grupeve njëkohësisht
Në një program mund të krijohen dhe të shfrytëzohen disa grupe në të njëjtën
kohë dhe njëkohësisht të kombinohen vlerat e tyre.
Në një program nuk lejohen grupime në të cilat përfshihen të dhëna të njëjta:
47. Të shkruhet programi në të cilin deklarohen dy grupe me emrin moti dhe
koha. Grupi moti të përmbajë gjendjet: kthjellet, vranet, ere, ftohte dhe
diell; kurse grupi koha të përmbajë: mjegull, shi dhe bore. Duke përdorur
komandën if të kontrollohen disa gjendje dhe të shtypet mesazhi sipas
modelit të mëposhtëm. Moti është i ftohtë dhe me shi

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
57
#include <iostream>
using namespace std;
enum moti
{
kthjellet,
vranet,
ere,
ftohte,
diell
} mt;
enum koha
{
mjegull,
shi,
bore
} kh;
int main()
{
mt=ftohte;
kh=bore;
if (mt ==ftohte && kh== shi)
{
cout<<"Moti është i ftohtë dhe me shi\n";
}
else if (mt ==ftohte && kh== bore)
{
cout<<"Moti është i ftohtë dhe me borë\n";
}
system("pause");
return 0;
}
3.8. Të dhënat e numëruara në nënprograme
Të dhënat e numëruara mund të përdoren në nënprograme (funksione), qoftë
brenda tyre apo edhe si parametra të funksioneve.
48. Të shkruhet programi në të cilin deklarohet një grup me emrin Motori
si dhe funksioni Kontrollo i cili ka si parametër hyrës grupin Motori.
Grupi përmban dy vlera ON dhe OFF. Funksioni Kontrollo të thirret për ON
dhe për OFF.
#include <iostream>
using namespace std;
enum Motori
{
OFF,
ON
} statusi;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
58
void Kontrollo(enum Motori);
int main()
{
statusi = OFF;
Kontrollo( statusi);
statusi = ON;
Kontrollo( statusi);
system("pause");
return 0;
}
void Kontrollo(Motori gjendja)
{
if (gjendja==ON)
cout<<"Motori është i ndezur\n";
else
cout<<"Motori është i fikur\n";
}
49. Nëse është dhënë grupi pozita, të shkruhet programi i cili i mundëson
përdoruesit të shtyp shkronjën e parë (a, s, m, k, p), dhe tipin e
zgjedhur ta ruajë si vlerë të variablës së tipit enum. Në fund përmes
funksionit shtypja i cili si parametër ka grupin të shtypet emri i plotë e
pozitës.
#include <iostream>
using namespace std;
enum pozita
{
asistent,
sekretar,
menagjer,
kontabilist,
programues
} puna;
void shtypja(pozita vendi)
{
if (vendi==asistent)
cout<<"Pozita e zgjedhur ‰sht‰ asistent\n";
else if (vendi==sekretar)
cout<<"Pozita e zgjedhur ‰sht‰ sekretar\n";
else if (vendi==menagjer)
cout<<"Pozita e zgjedhur ‰sht‰ menagjer\n";
else if (vendi==kontabilist)
cout<<"Pozita e zgjedhur ‰sht‰ kontabilist\n";
else if (vendi==programues)
cout<<"Pozita e zgjedhur ‰sht‰ programues\n";
}
int main()
{
char sh;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
59
cout<<"Zgjidh nj‰ profesion:\n"
<<"a:asistent\n"
<<"s:sekretar\n"
<<"m:menagjer\n"
<<"k:kontabilist\n"
<<"p:programues\n";
cin >>sh;
switch (sh)
{
case 'l':
puna=asistent;
break;
case 's':
puna=sekretar;
break;
case 'm':
puna=menagjer;
break;
case 'k':
puna=kontabilist;
break;
case 'p':
puna=programues;
break;
default:
break;
}
shtypja(puna);
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
60
4. Strukturat
Fushat numerike janë shfrytëzuar për mbajtjen e të dhënave homogjene apo të
dhënave të tipit të njëjtë.
Në disa situata, paraqitet nevoja për të grupuar të dhëna heterogjene apo të
llojeve të ndryshme, duke krijuar tipa të ri, të cilët njihen si struktura.
Struktura (ang. structure) është një koleksion i të dhënave me tipa të
ndryshëm, përkatësisht të dhëna heterogjene. Struktura paraqet një tip të
dhënash të përcaktuar nga përdoruesi i cili përcaktohet duke përdorur fjalën
çelës struct.
4.1. Krijimi i strukturave të zakonshme
Strukturat, para se të shfrytëzohen, duhet të krijohen duke e përdorur
komandën struct.
Një shembull i krijimit të strukturës është dhënë në figurën e mëposhtme

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
61
50. Të deklarohet një strukturë me emrin personi e cila përmban emrin,
mbiemrin, qytetin dhe vitin e lindjes.
struct personi
{
char emri[15];
char mbiemri[20];
char qyteti[20];
int vitilindjes;
};
4.2. Deklarimi i variablave të strukturës
Sintaksa e deklarimit të variablës me tip të strukturës
51. Për strukturën e krijuar në shembullin paraprak të deklarohet variabla
me emrin personi1 e tipit personi.
#include <iostream>
using namespace std;
struct personi
{
char emri[15];
char mbiemri[20];
char qyteti[20];
int vitilindjes;
};
int main()
{
personi personi1;
return 0;
}
4.3. Qasja në anëtarët e strukturës
Për të iu qasur anëtarëve të strukturës përdoret emri i variablës së
strukturës dhe emri i anëtarit të strukturës të ndarë me pikë.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
62
52. Për strukturën e dhënë struct pjesa {int modeli;int nrpjeses; float
kosto;}; të deklarohet variabla pjesa1 dhe të vendosen vlera për secilin
anëtar të strukturës. Më pas të shtypen vlerat e secilit anëtar.
#include <iostream>
using namespace std;
struct pjesa //deklarimi i strukturës
{
int modeli;
int nrpjeses;
float kosto;
};
int main()
{
//****** Deklarimi i variablës së strukturës
pjesa pjesa1;
//****** Vendosja e vlerave për anëtarët e strukturës
pjesa1.modeli = 5060;
pjesa1.nrpjeses = 135;
pjesa1.kosto = 217.55;
//****** Shfaqja e anëtarëve
cout << "Modeli " << pjesa1.modeli
<< ", numri i pjesës " << pjesa1.nrpjeses
<< ", kostoja " << pjesa1.kosto
<< endl;
system("pause");
return 0;
}
4.4. Deklarimi direkt i variablës së strukturës
Gjatë krijimit të strukturës, njëkohësisht mund të deklarohet edhe variabla e
strukturës.
53. Të krijohet struktura orari e cila ruan kohen e fillimit (float) dhe
kohën e mbarimit (float). Për strukturën orari të bëhet deklarimi direkt
i variablës, me emrin koha. Më pas të lexohet nga tastiera, koha e
fillimit dhe e mbarimit si dhe të shtypen vlerat e anëtarëve të
strukturës.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
63
#include <iostream>
using namespace std;
struct orari
{
float fillimi;
float mbarimi;
}
koha;
int main()
{
cout << "\nShfrytëzimi i variablës koha\n"
<< "-----------------------------------";
cout << "\n\nJep kohën e fillimit: ";
cin >> koha.fillimi;
cout << "Jep kohën e mbarimit: ";
cin >> koha.mbarimi;
cout << "\n\nKoha e fillimit:"
<< koha.fillimi;
cout << "\nKoha e mbarimit:"
<< koha.mbarimi
<< "\n\n";
system ("pause");
return 0;
}
4.5. Inicimi direkt i variablave
Variabla e strukturës mund të iniciohet direkt me vlera gjatë deklarimit të
strukturës.
54. Të krijohet struktura koordinata e cila ruan koordinatat e pikës A.
Variabla pika, e strukturës të iniciohet direkt gjatë deklarimit dhe më
pas të shtypen vlerat e anëtarëve të strukturës.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
64
#include <iostream>
using namespace std;
struct koordinata
{
float x;
float y;
};
int main()
{
koordinata pika={9.5, 4.8};
cout<< "Koordinatat e pikes janë:\nx="
<<pika.x
<< "\ny="
<< pika.y
<< endl;
system("pause");
return 0;
}
55. Të shkruhet programi për krijimin e strukturës llogaria_bankare e cila
ruan të dhënat: emri dhe mbiemri i mbajtësit të llogarisë (char), numri i
llogarisë (int), bilanci (double) dhe interesi (double). Për strukturën
llogaria_bankare të bëhet deklarimi direkt i variablës, me emrin klienti.
Vlerat të lexohen përmes tastierës dhe më pas të shtypen vlerat e lexuara.
#include <iostream>
using namespace std;
struct llogaria_bankare
{
char emri[15];
char mbiemri[20];
int numri;
double bilanci;
double interesi;
} klienti;
int main()
{
cout<< "\nSheno emrin: ";
cin>>klienti.emri;
cout<< "Sheno mbiemrin: ";
cin>>klienti.mbiemri;
cout<< "Shëno numrin e llogarisë";
cin>>klienti.numri;
cout<< "Shëno bilancin: ";
cin>>klienti.bilanci;
cout<< "Shëno interesin: ";
cin>>klienti.interesi;
cout<<klienti.emri <<" "
<<klienti.mbiemri
<< " me numër të llogarisë"
<<klienti.numri

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
65
<<"\nka të deponuara në bankë "
<<klienti.bilanci
<<"Euro me interes "
<<klienti.interesi;
system("pause");
return 0;
}
4.6. Llogaritje me variablat e strukturës
Variablat e përfshira në strukturë mund të shfrytëzohen për llogaritje ashtu
siç shfrytëzohen edhe variablat e zakonshme. Para variablave duhet të
shënohet emri i strukturës dhe pika si operator për qasje në anëtarë të
strukturës.
Për llogaritje më të lehtë, vlerat e variablave të strukturës mund të ruhen
edhe në variabla të zakonshme, p.sh x1=art.sasia;
56. Të krijohet struktura drejtkendeshi, e cila ruan gjatësinë e brinjës a
dhe b. Më pas të llogaritet dhe të shtypet sipërfaqja e drejtkëndëshit
duke shfrytëzuar variablat e strukturës.
#include <iostream>;
using namespace std;
struct drejtkendeshi
{
double a, b;
};
int main()
{
drejtkendeshi brinja = {5, 8};
double s;
cout<< "\nVlerat e variablave të strukturës"
<<"\n-------------------------------------"
<< "\nVlera e brinjës a: "
<< brinja.a
<< "\nVlera e brinjës b: "
<< brinja.b;
s=brinja.a*brinja.b;
cout << "\n-------------------------------------"

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
66
<< "\nSipërfaqja e drejtkënëshit s="
<< s
<< "\n\n";
system("pause");
return 0;
}
57. Numri i telefonit mund të ndahet në tre pjesë, p.sh (44) 181-906. Të
shkruhet programi i cili përdor strukturën telefoni për të ruajtur këto
tri pjesë të numrit si të ndara. Krijo një variabël të strukturës dhe lexo
numrin përmes tastierës. Në fund të shtypet numri i lexuar.
#include <iostream>
using namespace std;
struct telefoni
{
int prefiksi; //prefiksi (2 shifra)
int pjesa1; //pjesa1 (3 shifra)
int pjesa2; //numri (3 shifra)
};
int main()
{
telefoni tel;
cout<< "\nSheno numrin e telefonit\n"
<<"prefiksi (2 shifra), pjesa e parë (3 shifra), pjesa e dytë (3 shifra).";
cin >> tel.prefiksi >> tel.pjesa1 >> tel.pjesa2;
cout << "\nNumri im është "
<< "(" << tel.prefiksi << ") "
<< tel.pjesa1 << "-"
<< tel.pjesa2
<< endl;
system("pause");
return 0;
}
58. Të shkruhet programi dhe të krijohet struktura vellimi, e cila ruan
sipërfaqen e bazës dhe lartësinë e piramidës. Duke shfrytëzuar variablat e
strukturës të llogaritet vëllimi i piramidës.
#include <iostream>;
using namespace std;
struct vellimi
{
double siperfaqja, lartesia;
};
int main()
{
vellimi vell = {50.80, 12.5};
double v;
cout<< "\nVlerat e variablave t렳truktures"

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
67
<<"\n-------------------------------------"
<< "\nSiperfaqja e piramides : "
<< vell.siperfaqja
<< "\nLartesia e piramides : "
<< vell.lartesia;
v=(vell.siperfaqja*vell.lartesia)/3;
cout << "\n-------------------------------------"
<< "\nVellimi i piramides V="
<< v
<< "\n\n";
system("pause");
return 0;
}
59. Të shkruhet programi dhe të krijohet struktura studentet, e cila ruan
ID-në dhe notat në programim, algoritme, matematikë dhe fizikë. Duke
shfrytëzuar variablat e strukturës të llogaritet nota mesatare e
studentit.
#include <iostream>;
using namespace std;
struct studentet
{
int id;
int matematike;
int programim;
int fizike;
int algoritme;
} studenti;
int main()
{
studenti.id=12345;
cout<< "Nota ne matematikë: ";
cin >>studenti.matematike;
cout<< "Nota ne programim: ";
cin >>studenti.programim;
cout<< "Nota ne fizike: ";
cin >>studenti.fizike;
cout<< "Nota ne algoritme: ";
cin >>studenti.algoritme;
cout<<"\n-------------------------------------"
<< "\nNota mesatare e studentit "
<< studenti.id
<< "\nështë "
<< (studenti.matematike + studenti.programim +
studenti.fizike+studenti.algoritme)/4
<< "\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
68
4.7. Ruajtja e të dhënave në strukturë
Për ruajtjen e rezultateve të ndryshme mund të shfrytëzohen edhe
variablat e komponentëve/anëtarëve të strukturës.
60. Të shkruhet programi për llogaritjen e faktorielit F = (2m − n + 1)!.
Vlerat e m, n dhe F të ruhen në strukturën alfa.
#include <iostream>
using namespace std;
struct alfa
{
int m,n;
double F;
};
int main()
{
alfa fakt;
int i;
cout << "\nVlerat hyrese"
<< "\nVariabla m: ";
cin >> fakt.m;
cout << "\nVariabla n: ";
cin >> fakt.n;
fakt.F=1;
for (i=1;i<=(2*fakt.m-fakt.n+1);i++)
fakt.F=fakt.F*i;
cout << "\nVlera e llogaritur F="
<< fakt.F
<< "\n\n";
system("pause");
return 0;
}
61. Të shkruhet programi për llogaritjen e shprehjes së mëposhtme. Vlerat e
x, n dhe y të ruhen në strukturën shuma.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
69
#include <iostream>
using namespace std;
struct shuma
{
int x,n;
double y;
};
int main()
{
shuma vlera;
int i;
cout << "\nVlerat hyrëse"
<< "\nVlera x= ";
cin >> vlera.x;
cout << "Variabla n: ";
cin >> vlera.n;
vlera.y=0;
for (i=1;i<=vlera.n;i++)
vlera.y=vlera.y+ (vlera.n+2*i);
cout << "\nVlera e llogaritur y="
<< 4*pow((vlera.x+1),2.)-2* vlera.y
<< "\n\n";
system("pause");
return 0;
}
4.8. Disa variabla të një strukture
Sintaksa e deklarimit të variablave të strukturës është si më poshtë:
Më poshtë shihet se si për strukturën me emrin fiek janë deklaruar dy
variabla me emrin profesori dhe studenti.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
70
62. Të shkruhet programi për leximin dhe shtypjen e emrit dhe qytetit të
profesorit dhe të studentit duke shfrytëzuar strukturën personi. Të
deklarohen dy variabla, një profesori dhe një studenti.
#include <iostream>
using namespace std;
struct personi
{
char emri[8],qyteti[10];
int viti;
};
int main()
{
personi profesori,studenti;
cout << "\nTë dhenat nga tastiera\n\n";
cout << "Qyteti i profesorit ...: ";
cin >> profesori.qyteti;
cout << "Qyteti i studentit ....: ";
cin >> studenti.qyteti;
cout << "\n\nTe dhënat e lexuara\n";
cout << "\nProfesori është nga "
<< profesori.qyteti;
cout << "\nStudenti është nga "
<< studenti.qyteti
<< "\n\n";
system("pause");
return 0;
}
63. Nëse është dhënë struktura: struct filmat {string titulli; int viti;}
imi, juaji; Të shkruhet programi i cili lexon nga tastiera filmin e
preferuar dhe vitin. Përmes funksionit printo të shtypet filmi i preferuar
për ju dhe për shokun tuaj.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
71
#include <iostream>
#include <string>
using namespace std;
struct filmat
{
string titulli;
int viti;
} imi, juaji;
void printo(filmat filmi);
int main()
{
string mystr;
imi.titulli = "Avatar";
imi.viti = 2009;
cout << "Titulli i filmit të preferuar: ";
getline(cin,juaji.titulli);
cout << "Viti: ";
cin>>juaji.viti;
cout << "Filmi im i preferuar është:\n";
printo (imi);
cout << "kurse i juaji është:\n";
printo (juaji);
system("pause");
return 0;
}
void printo (filmat filmi)
{
cout << filmi.titulli;
cout << " (" << filmi.viti << ")\n";
}
4.9. Përdorimi i operacionit të shoqërimit
Nëse janë deklaruar dy variabla v1 dhe v2 të strukturës s, përmes
operacionit të shoqërimit:
Të gjitha vlerat e anëtarëve (variablave) të variablës v1 u shoqërohen
anëtarëve përkatëse të variablës v2.
v2= v1;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
72
64. Të shkruhet programi dhe të krijohet struktura produkti e cila ruan
peshën dhe çmimin e produktit. Të deklarohet variabla e strukturës molla
dhe të iniciohet me vlera. Këto vlera të vendosen në variablen e re të
strukturës të quajtur dardha. Në fund të printohen vlerat e të dy
variablave të strukturës.
#include <iostream>
using namespace std;
struct produkti
{
float pesha, cmimi;
} ;
int main()
{
produkti molla = {5.5,6.4};
produkti dardha;
dardha=molla;
cout << "\nVlerat e variablave pas shoqërimit ";
cout << "\n\nMollat: "
<< molla.pesha
<< " kg kushtojnë "
<< molla.cmimi;
cout << "\nDardhat: "
<< dardha.pesha
<< " kg kushtojnë "
<< dardha.cmimi
<< "\n\n";
system ("pause");
return 0;
}
65. Të shkruhet programi dhe të krijohet struktura telefoni e cila ruan id-
në dhe çmimin e telefonit. Të deklarohen variablat e strukturës samsung
dhe iphone. Çmimi i variablës samsung të lexohen nga tastiera, kurse
çmimi i variablës iphone është për 25% më i lartë se çmimi i samsung. Të
shtypen id-të dhe çmimet e të dy telefonave duke i shfrytëzuar variablat e
strukturës.
#include <iostream>
using namespace std;
struct telefoni
{

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
73
int id;
float cmimi;
};
int main()
{
telefoni samsung, iphone;
samsung.id=1010;
iphone.id=2020;
cout << "\nSa kushton telefoni Samsung?= ";
cin >> samsung.cmimi;
iphone.cmimi=samsung.cmimi+0.25*samsung.cmimi;
cout << "\n\nTelefoni Samsung <"
<<samsung.id
<<"> kushton "
<<samsung.cmimi;
cout<< " Euro\n\nTelefoni Iphone<"
<<iphone.id
<<"> kushton "
<<iphone.cmimi
<< " Euro\n\n";
system ("pause");
return 0;
}
4.10. Përdorimi i operatorëve relacionalë
Operatorët relacionalë nuk mund të zbatohen direkt mbi strukturat, por vetëm
mbi komponentët përkatëse të tyre.
66. Të shkruhet programi dhe të krijohet struktura brinjet, e cila ruan
brinjën a dhe b. Më pas të llogaritet sipërfaqja e katërkëndëshit dhe nëse
brinja a dhe b janë të barabarta të shtypet mesazhi “Sipërfaqja e katrorit
s=“, në të kundërtën të shtypet “Sipërfaqja e drejtkëndëshit s=“.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
74
#include <iostream>
using namespace std;
struct brinjet
{
double a,b;
};
int main64()
{
brinjet kater;
double s;
cout << "Vlera e brinjës a: ";
cin >> kater.a;
cout << "Vlera e brinjës b: ";
cin >> kater.b;
s=kater.a*kater.b;
if (kater.a==kater.b)
{
cout<< "\nSipërfaqja e katrorit s="
<< s
<< "\n\n";
}
else
{
cout<< "\nSipërfaqja e drejtkëndëshit s="
<< s
<< "\n\n";
}
system("pause");
return 0;
}
4.11. Disa struktura njëkohësisht
Në një program njëkohësisht mund të krijohen edhe disa struktura. Gjatë kësaj
çdo strukturë duhet ta ketë emrin dhe komponentët me variablat që përfshihen
brenda saj. Dy struktura të ndryshme mund të kenë variabla me emërtime të
njëjta.
67. Të shkruhet programi dhe të krijohen strukturat brinjet dhe rrezja. Më
pas të llogaritet dhe të shtypet sipërfaqja dhe perimetri i katërkëndëshit
dhe rrethit.
#include <iostream>
using namespace std;
struct brinjet
{
double a,b;
};

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
75
struct rrezja
{
double r;
};
int main()
{
brinjet kater = {4,5};
rrezja rrethi = {6};
double sk,pk,sr,pr;
const double pi=3.1415926;
cout << "Vlerat e variablave në dy strukturat"
<< "\n\nVlera e brinjes a: "
<< kater.a;
cout << "\nVlera e brinjës b: "
<< kater.b;
cout << "\nVlera e rrezës: "
<< rrethi.r;
sk=(kater.a*kater.b);
pk=2*kater.a+2*kater.b;
cout << "\n\nSiperfaqja e katërkëndëshit \tsk="
<< sk
<< "\nPerimetri i katërkëndëshit \tpk="
<< pk;
sr=pi*(rrethi.r*rrethi.r);
pr=2*pi*rrethi.r;
cout << "\nSipërfaqja e rrethit \t\tsr="
<< sr
<< "\nPerimetri i rrethit \t\tpr="
<< pr
<< "\n\n";
system("pause");
return 0;
}
4.12. Strukturat e ndërthurura
Strukturat mund të jenë anëtarë të strukturave të tjera - struktura të
ndërthurura. Ky lloj i përdorimit krijon pemën e strukturave - struktura
hierarkike.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
76
Personi është strukturë prind për Studenti dhe Profesori. Çdo strukturë
fëmijë ka të gjithë anëtarët e prindit dhe përveç kësaj, zakonisht ka edhe
anëtarët e vet.
68. Të shkruhet programi përmes së cilit tregohet shfrytëzimi i strukturave
provimi (nr, nota) dhe personi (emri, mbiemri, lenda). Struktura provimi
le të jetë anëtar i strukturës personi.
#include <iostream>
using namespace std;
struct lenda
{
int nr;
unsigned short nota;
};
struct personi
{
char emri[10];
char mbiemri[15];
lenda algoritme;
};
int main()
{
personi studenti;
cout << "Emri dhe mbiemri: ";
cin >> studenti.emri >> studenti.mbiemri;
cout << "Numri i lendes: ";
cin >> studenti.algoritme.nr;
cout << "Nota ne provim: ";
cin >> studenti.algoritme.nota;
cout<< "\n\nTe dhenat e lexuara\n"
<<"*****************************"
<< "\nStudenti: "
<< studenti.emri <<" "
<<studenti.mbiemri
<< "\nNumri i lendes: "
<<studenti.algoritme.nr
<< "\nNota ne provim: "
<< studenti.algoritme.nota
<< "\n\n";
system("pause");
return 0;
}
69. Të shkruhet programi në të cilin deklarohet struktura punetori. Për
datën e pagesës të deklarohet struktura data e cila deklarohet brenda
strukturës punetori.
#include <iostream>
using namespace std;
struct punetori
{

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
77
char emri[20];
int id;
float paga;
struct data
{
int dita;
int muaji;
int viti;
}dt;
}pun = {"Peon Neziri",50,1250,{27,02,2012}};
int main()
{
cout<<"Punetori: " <<pun.emri
<<"\nID: " <<pun.id
<<"\nPaga: " <<pun.paga
<<"\nData e pageses: " <<pun.dt.dita
<<"/"<<pun.dt.muaji
<<"/"<<pun.dt.viti
<<endl;
system("pause");
return 0;
}
70. Të shkruhet programi në të cilin deklarohet struktura Kosto (derivate,
mirembjatje, regjistrim, tjera) dhe Vetura (emri, targa, prodhuar, kosto).
Kosto është strukturë e deklaruar brenda strukturës Vetura. Tek struktura
Vetura të përdoret konstruktori për inicimin e vlerave të klaës Kosto dhe
Vetura. Në funksionin main të deklarohet një veturë, të inicohet me vlera
si dhe të shtypen shënimet e veturës dhe shpenzimet vjetore.
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
struct Kosto
{
double derivate, //derivate për një vit
mirembajtje, //mirembajtje vjetore
regjistrim,
tjera;
};
struct Vetura
{
string emri;
string targa;
int prodhuar;
Kosto kosto; //struktura Brenda strukturës
Vetura() // konstruktori i nënkuptuar
{
emri = "";
targa = "";
prodhuar = 2000;
kosto.derivate = kosto.mirembajtje = kosto.regjistrim = kosto.tjera = 0.00;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
78
}
};
int main()
{
Vetura vet1;
vet1.emri = "Audi";
vet1.targa = "01-000-AB";
vet1.prodhuar = 2010;
vet1.kosto.derivate = 1500;
vet1.kosto.mirembajtje = 300;
vet1.kosto.regjistrim = 289.50;
cout << fixed << showpoint << setprecision(2);
cout << "Shpenzimet vjetore për << vet1.emri
<< " me targa "<< vet1.targa
<< " e prodhuar me "<<vet1.prodhuar
<< " janë "
<< (vet1.kosto.derivate + vet1.kosto.mirembajtje +
vet1.kosto.regjistrim + vet1.kosto.tjera)
<< " Euro."
<< endl;
system("pause");
return 0;
}
4.13. Strukturat si parametra të funksioneve
Variablat e strukturave mund të paraqiten edhe si parametra të funksioneve.
Parametrat formalë dhe ata aktualë duhet të përputhen mes vete për nga:
 numri
 tipi
 radha
71. Të shkruhet programi në të cilin deklarohet struktura student(emri,
indeksi, seksioni dhe semestri). Më pas të deklarohet variabla e
strukturës dhe të iniciohet me vlera. Shtypja e shënimeve të studentit të
bëhet përmes funksionit shtyp i cili si parametër ka strukturën studenti.
#include<iostream>

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
79
using namespace std;
struct studenti
{
char emri[20];
int indeksi;
char seksioni;
int semestri;
};
void shtyp(studenti);
int main( )
{
studenti stud={"Eugen",902012,'K',3};
cout<<"\nShenimet për studentin e zgjedhur janë:\n"<<endl;
shtyp(stud);
system("pause");
return 0;
}
void shtyp(studenti st)
{
cout<<"Emri:\t\t "<<st.emri<<endl;
cout<<"Indeksi:\t "<<st.indeksi<<endl;
cout<<"Seksioni:\t "<<st.seksioni<<endl;
cout<<"Semester:\t "<<st.semestri<<endl;
}
72. Të shkruhet programi në të cilin deklarohet struktura pikat. Kjo
strukturë të jetë parametër i funksionit distanca i cili kthen si rezultat
distancën në mes dy pikave.
#include <iostream>
using namespace std;
struct pikat
{
double x1, y1, x2, y2 ;
}pika;
double distanca(pikat p)
{
return sqrt(pow(p.x2 - p.x1, 2) + pow(p.y2 - p.y1, 2));
}
int main()
{
pika.x1=3;
pika.y1=4;
pika.x2=6;
pika.y2=7;
cout<<"Distanca ne mes pikave ("
<< pika.x1 <<"," << pika.x2
<<") dhe ("<< pika.y1<<","<< pika.y2
<<") = "

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
80
<<distanca (pika)
<< endl ;
system("pause");
return 0;
}
4.14. Disa nënprograme njëkohësisht
Variablat e strukturave pa ndonjë kufizim mund të përdoren njëkohësisht në
shumë nënprograme.
73. Të shkruhet programi për llogaritjen e shprehjes vijuese
h=3max(a,b)+(2m+n)!-5. Vlerat a dhe b të ruhen në strukturën alfa, kurse
vlerat m dhe n të ruhen në strukturën beta. Për llogaritjen e maksimumit
të përdoret funksioni max() i cili si parametër hyrës ka strukturën alfa,
kurse funksioni fakt() i cili si parametër hyrës ka strukturën beta të
përdoret për llogaritjen e faktorielit.
#include <iostream>
using namespace std;
struct alfa {double a,b;};
struct beta {int m,n;};
double max(alfa m)
{
if (m.a>m.b)
return m.a;
else
return m.b;
}
double fakt(beta fa)
{
int i;
double F=1;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
81
for (i=1;i<=(2*fa.m+fa.n);i++)
F=F*i;
return F;
}
int main()
{
int m=2,n=1;
double h;
alfa al={5,6};
beta be={m,n};
h=3*max(al)+fakt(be)-5;
cout << "\nVlera e funksionit h="<< h << "\n\n";
system("pause");
return 0;
}
74. Të shkruhet programi dhe të krijohet struktura artikulli (emri, cmimi,
sasia). Struktura të iniciohet me vlera të çfarëdoshme në funksionin main.
Më pas, çmimi dhe sasia të rriten përmes funksionit ndrysho(), kurse
totali të llogaritet përmes funksionit totali(). Në fund të shtypen vlerat
e ndryshuara të artikullit.
#include <iostream>
using namespace std;
struct artikulli
{
char emri[20];
float cmimi;
int sasia;
};
artikulli ndrysho (artikulli art, float cm, int sas);
float totali(artikulli stoku);
int main()
{
float c_rritja, tot;
int s_rritja;
artikulli art = {"Buka", 0.40, 120};
cout<<"\nPër sa don ta rritesh çmimin?:";
cin >>c_rritja;
cout<<"Për sa don ta shtosh sasine?:";
cin >>s_rritja;
art = ndrysho(art, c_rritja, s_rritja);
cout<<"\nShënimet e artikullit pas ndryshimeve\n"
<<"----------------------------------------"
<<"\nEmri :"<<art.emri
<<"\nmimi :"<<art.cmimi
<<"\nSasia :"<<art.sasia;
tot = totali(art);

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
82
cout<<"\nTotali :"<< tot<<endl;
system("pause");
return 0;
}
artikulli ndrysho(artikulli art, float cm, int sas)
{
art.cmimi += cm;
art.sasia += sas;
return(art);
}
float totali(artikulli stoku)
{
return(stoku.cmimi * stoku.sasia);
}
4.15. Funksionet në komponentët e strukturave
Përveç variablave, në komponentët e strukturave mund të paraqiten edhe
funksionet. Forma e përgjithshme e strukturës është:
4.15.1. Pa parametra formalë
Nëse brenda funksioneve shfrytëzohen vetëm variablat e komponentëve të
strukturës ku ato krijohen, në kllapat e tyre nuk shënohet asnjë parametër
formal.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
83
75. Të shkruhet programi përmes të cilit llogaritet distanca në mes dy
pikave. Për llogaritje të shfrytëzohet struktura pika dhe funksioni
distanca i cili është i deklaruar brenda strukturës pika.
#include <iostream>
using namespace std;
struct pika
{
int x1,x2;
int y1,y2;
double distanca()
{
return sqrt(pow(x2-x1,2.)+pow(y2-y1,2.));
}
}p;
int main()
{
pika p;
double d;
cout<< "\nPika 1:\nx1= ";
cin >> p.x1;
cout<< "y1= ";
cin >> p.y1;
cout<< "\nPika 2:\nx2= ";
cin >> p.x2;
cout<< "y2= ";
cin >> p.y2;
d=p.distanca();
cout << "\nDistanca d="
<< d << "\n\n";
return 0;
}
4.15.2. Me parametra formalë
Nëse funksionet që paraqiten në komponentët e strukturave shfrytëzojnë
variabla që nuk përfshihen në strukturë, ato duhet të shënohen si parametra
formalë.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
84
76. Të shkruhet programi përmes të cilit llogaritet shprehja e mëposhtme.
Për llogaritje të shfrytëzohen struktura alfa dhe funksioni beta i cili
është i deklaruar brenda strukturës alfa.
#include <iostream>
using namespace std;
struct alfa
{
int a,b;
double beta(double x,double y)
{
int i;
if (x>y)
return a*x+y;
else
return 6*x-2*b;
};
};
int main()
{
alfa str;
double x,y,z;
cout << "Vlera x= ";
cin >> x;
cout << "Vlera a= ";
cin >> str.a;
cout << "Vlera b= ";
cin >> str.b;
cout << "Vlera y: ";
cin >> y;
z=str.beta(x,y);
cout << "\nVlera e llogaritur z="
<< z << "\n\n";
system("pause");
return 0;
}
77. Të shkruhet programi përmes të cilit llogaritet shprehja e mëposhtme.
Për llogaritje të shfrytëzohen struktura alfa dhe funksioni beta i cili
është i deklaruar jashtë strukturës alfa.
#include <iostream>
using namespace std;
struct alfa
{
int a,b;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
85
double beta(double x,double y);
};
double alfa::beta(double x,double y)
{
int i;
if (x>y)
return a*x+y;
else
return 6*x-2*b;
};
int main()
{
alfa str;
double x,y,z;
cout << "Vlera x= ";
cin >> x;
cout << "Vlera a= ";
cin >> str.a;
cout << "Vlera b= ";
cin >> str.b;
cout << "Vlera y: ";
cin >> y;
z=str.beta(x,y);
cout << "\nVlera e llogaritur z="
<< z << "\n\n";
system("pause");
return 0;
}
78. Të shkruhet programi përmes të cilit llogaritet shprehja e mëposhtme.
Për llogaritje të shfrytëzohen struktura gama dhe funksioni shuma i cili
është i deklaruar jashtë strukturës gama.
#include <iostream>
using namespace std;
struct gama
{
double x;
int n;
double shuma();
};
double gama::shuma()
{
int i;
double s=0;
for (i=1;i<=(n-1);i++)
s=s+(2*i-1);
return x/3+s;
};

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
86
int main()
{
gama str;
double y;
cout << "\nx= ";
cin >> str.x;
cout << "n= ";
cin >> str.n;
y=str.shuma();
cout << "\nVlera e llogaritur y="
<< y << "\n\n";
system("pause");
return 0;
}
4.16. Fushat në struktura
Në komponentët e strukturave mund të vendosen edhe fusha numerike (vektor,
matrica...). Rezervimi i vendeve të nevojshme për fushat bëhet përmes
deklarimit të një konstanteje para krijimit të strukturave.
79. Të shkruhet programi në të cilin krijohet struktura vleresimi e cila si
komponentë e ka vektorin notat të madhësisë m. Vektori notat të iniciohet
me vlera dhe më pas të shtypen vlerat e tij.
#include <iostream>
#include <iomanip>
using namespace std;
const int m=10;
struct vleresimi
{
int notat[m];
};
int main()
{
int i;
double x;
vleresimi vlera = {8,6,9,10,5,10,9};
cout << "\nAnetaret e vektorit notat\n";
for (i=0;i<m;i++)
cout<< setw(4)

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
87
<< i
<< setw(10)
<< vlera.notat[i]
<< "\n";
system("pause");
return 0;
}
80. Të shkruhet programi në të cilin krijohet struktura fiek e cila si
komponentë e ka vektorin notat me madhësi m. Duke përdorur funksionin
mesatare i cili është i deklaruar brenda strukturës, të gjendet nota
mesatare. Në fund të shtypen notat dhe nota mesatare.
#include <iomanip>
#include <iostream>
using namespace std;
const int m=6;
struct fiek
{
int notat[m];
float mesatare();
};
int main()
{
int i;
fiek Vlera = {10,9,8,9,10,7};
cout<< "\nNotat"
<< "\n------------------------\n";
for (i=0;i<m;i++)
cout << setw(4)
<< i
<< setw(10)
<< Vlera.notat[i]
<<endl;
cout<< "\n------------------------\n"
<< "Nota mesatare nm= "
<< Vlera.mesatare()
<< "\n\n";
system("pause");
return 0;
}
float fiek::mesatare()
{
float nm=notat[0];
int i;
for (i=1;i<m;i++)
nm=nm+notat[i];
nm=nm/m;
return nm;
};

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
88
4.17. Fushat e strukturave
Mund të krijohen edhe fusha të strukturave, ngjashëm si fushat e zakonshme.
Në një element të fushës përfshihen të dhënat e të gjitha komponentëve
përkatëse të strukturës.
81. Të shkruhet programi në të cilin deklarohet vektori i strukturës,
studenti[n], i tipit personi. Struktura personi të përmbajë komponentët
emri, mbiemri dhe vitilindjes. Të dhënat për n-studentë të lexohen nga
tastiera dhe më pas të shtypen ato të dhëna.
#include <iostream>
#include <iomanip>
using namespace std;
struct personi
{
char emri[15], mbiemri[20];
int vitilindjes;
};
int main()
{
const int n=3;
int i;
personi studenti[n];
cout << "\nTë dhenat nga tastiera\n\n";
for (i=0;i<n;i++)
{
cout << "Emri dhe mbiemri: ";
cin >> studenti[i].emri>> studenti[i].mbiemri;
cout << "Viti i lindjes: ";
cin >> studenti[i].vitilindjes;
cout << "\n";
}
cout << "\nTë dhenat e lexuara\n\n"
<< "Emri dhe mbiemri VitiLindjes"
<< "\n-----------------------------\n";
for (i=0;i<n;i++)
{
cout<< studenti[i].emri <<" " <<studenti[i].mbiemri;
cout << setw(15) << studenti[i].vitilindjes << endl;
}
cout << "-----------------------------\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
89
5. Klasat
Klasa është një mënyrë për të lidhur të dhënat dhe funksionet së
bashku. Klasa është koleksion i një numri të caktuar të komponentëve e
të cilat komponentë quhen anëtarë të klasës. Me fjalë tjera, klasat
janë strukturat + funksionet.
Derisa qasja e nënkuptuar (ang. default access) të strukturat është
publike (ang. public), të klasat, qasje e nënkuptuar është private
(ang. private).
5.1. Krijimi i klasave të zakonshme
Krijimi i klasës fillon me fjalën çelës (keyword) class.
82. Të krijohet klasa me emrin personi e cila përmban emrin, mbiemrin,
qytetin dhe vitin e lindjes.
class personi
{
public:
char emri[15];
char mbiemri[20];
char qyteti[20];
int vitilindjes;
};
5.2. Deklarimi i objekteve
Objekti është një instancë e klasës. Deklarimi bëhet sikurse edhe deklarimi i
variablave të tjera. Sintaksa e deklarimit të objektit është:

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
90
Gjatë krijimit të një klase nuk rezervohet memorie, memoria rezervohet për
variablen e klasës, d.m.th gjatë deklarimit të objektit.
83. Për klasën e krijuar në shembullin paraprak të deklarohet objekti me
emrin studenti1.
#include <iostream>
using namespace std;
class personi
{
public:
char emri[15];
char mbiemri[20];
char qyteti[20];
int vitilindjes;
};
int main()
{
personi studenti1;
return 0;
}
5.3. Qasja në komponentët e klasës
Qasja në anëtarët e klasës bëhet duke përdorur operatorin . (pikë).
Shembull, për klasën studenti, është deklaruar objekti studenti1 dhe është
bërë qasja në anëtarin emri.
84. Të iniciohen me vlera anëtarët e klasës së dhënë personi në shembullin
paraprak. Më pas të shtypen vlerat e anëtarëve.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
91
#include <iostream>
using namespace std;
class personi
{
public:
char emri[15];
char mbiemri[20];
char qyteti[20];
int vitilindjes;
};
int main()
{
personi studenti1;
cout << "\nShëno të dhënat e studentit\n";
cout << "Emri dhe mbiemri: ";
cin >> studenti1.emri>>studenti1.mbiemri;
cout << "Qyteti: ";
cin >> studenti1.qyteti;
cout << "Viti i lindjes: ";
cin >> studenti1.vitilindjes;
cout << "\n\nTë dhënat e lexuara\n";
cout<< "\nEmri dhe mbiemri: "
<< studenti1.emri
<< " "
<< studenti1.mbiemri;
cout << "\nQyteti: "
<< studenti1.qyteti;
cout << "\nViti i lindjes: "
<< studenti1.vitilindjes << "\n\n";
return 0;
}
85. Të shkruhet programi, përmes së cilit krijohet klasa artikulli në
anëtarët e së cilës paraqiten ID, Emërtimi, Sasia dhe Çmimi. Vlerat e
anëtarëve të iniciohen duke i lexuar përmes tastierës dhe më pas të
shtypen këto vlera.
#include<iostream>
#include <iomanip>
using namespace std;
class artikulli
{
public:
int id;
char emertimi[15];
double sasia;
double cmimi;
};
int main()
{
artikulli art;
cout << "\nShëno të dhënat e artikullit\n";
cout << "ID: ";

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
92
cin >> art.id;
cout << "Emertimi: ";
cin >> art.emertimi;
cout << "Sasia: ";
cin >> art.sasia;
cout << "ǭimi: ";
cin>> art.cmimi;
cout<<"\nTë dhënat e artikullit\n"
<<"----------------------------------------"
<<"\nID:"
<< setw (10)<<"Emri"
<< setw (15) <<"Sasia"
<<setw (10) <<"Cmimi\n"
<<"----------------------------------------\n"
<<art.id
<<setw (10)<<art.emertimi
<<setw (15)<<art.sasia
<<setw (10)<<art.cmimi
<<endl;
system("pause");
return 0;
}
5.4. Forma e përgjithshme e klasave
Anëtarët e klasave janë të klasifikuar në tri kategori: public, private dhe
protected.
Në C++, fjalët private, protected, dhe public janë fjalë të rezervuara dhe
quhen specifikuesit e qasjes. Nëse anëtari i klasës është variabël, deklarimi
bëhet njëjtë sikurse variablat tjera. Gjatë krijimit të klasës, variabla nuk
mund të iniciohet. Nëse anëtari i klasës është funksion, përdoret prototipi i
funksionit për të deklaruar atë anëtar. Zakonisht, anëtarët me të dhëna
deklarohen si privat, kurse funksionet si publike. Skema e mëposhtme paraqet
pjesën private dhe publike të klasës. Shihet qartë se tek anëtarët privat nuk
lejohet hyrja apo qasja nga jashtë klasës, por atyre anëtarëve duhet qasur
përmes funksioneve që janë të pjesa publike.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
93
86. Të shkruhet programi, përmes të cilit krijohet klasa katrori në
anëtarët e së cilës paraqitet variabla private, krahu dhe variabla
publike, varpub, si dhe funksionet publike vendos_vleren dhe lexo_vleren.
Në funksionin main të implementohet vendosja dhe leximi i vlerave përmes
variablës private dhe publike.
#include <iostream>
using namespace std;
class katrori
{
private:
int krahu;
public:
int varpub;
void vendos_vleren(int k)
{
krahu = k;
}
int lexo_vleren()
{
return krahu;
}
};
int main()
{
katrori kat;
cout << "Vlera e brinjes a: ";
cin>>kat.varpub;
kat.vendos_vleren(55);
cout<<"Vlera e variablës publike = "
<<kat.varpub;
cout << "\nVlera e variablës private = "
<< kat.lexo_vleren()
<< "\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
94
5.5. Shfrytëzimi i funksioneve brenda klasës
Edhe tek klasat (sikurse edhe tek strukturat), funksionet mund të krijohen
jashtë trupit të klasave, por, brenda klasave duhet të shënohen prototipat e
funksioneve.
87. Të shkruhet programi, përmes së cilit krijohet klasa rrethi. Brenda
klasës të krijohet rrezja si private dhe prototipat e funksioneve si
publike. Funksionet vendos_rrezen dhe siperfaqja të implementohen jashtë
klasës
#include <iostream>
using namespace std;
const double pi=3.1415;
class rrethi
{
private:
double rrezja;
public:
void vendos_rrezen(double);
double siperfaqja();
};
void rrethi::vendos_rrezen(double r)
{
rrezja = r;
}
double rrethi::siperfaqja()
{
return pi * rrezja * rrezja ;
}
int main()
{
rrethi rr;
rr.vendos_rrezen(5.6);
cout<<"Siperfaqja e rrethit = "
<<rr.siperfaqja()
<< "\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
95
88. Të shkruhet programi, përmes të cilit krijohet klasa katerkendeshi në
komponentët e së cilës paraqitet variablat private, gjatesia dhe lartesia
si dhe funksionet publike, vendos_gjatesine, vendos_lartesine, siperfaqja
dhe perimetri. Në funksione të llogaritet sipërfaqja, respektivisht
perimetri i katërkëndëshit kënddrejtë.
#include <iostream>
#include <iomanip>
using namespace std;
class katerkendeshi
{
public:
double perimetri()
{
return 2 * ( gjatesia + lartesia );
};
double siperfaqja()
{
return gjatesia * lartesia;
};
void vendos_gjatesine( double g )
{
gjatesia = g ;
}
void vendos_lartesine(double l)
{
lartesia = l;
}
private:
double lartesia;
double gjatesia;
};
int main()
{
katerkendeshi kater;
kater.vendos_gjatesine(5.5);
kater.vendos_lartesine(3.4);
cout<<"Perimetri = " <<kater.perimetri()
<<"\nSiperfaqja = " <<kater.siperfaqja()
<< endl;
system("pause");
return 0;
}
5.6. Forma të tjera të inicimit të variablave
Skema e mëposhtme paraqet inicimin përmes leximit. Duke përdorur funksionin
leximi, vlera e variablës private a iniciohet me një vlerë të dhënë përmes
tastierës.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
96
Një formë tjetër e inicimit të variablave është edhe gjatë deklarimit të
objektit të klasës. Në skemën e mëposhtme është deklaruar klasa me emrin
klasa dhe më pas tek funksioni main është deklaruar objekti kl dhe është
iniciuar me vlera.
89. Të krijohet klasa me emrin inicimi e cila përmban variablën private me
emrin variabla dhe dy funksione publike, leximi për inicimin e variablës
dhe funksioni shtypja për shtypjen e vlerës së variablës.
#include<iostream>
using namespace std;
class inicimi
{
private:
int variabla;
public:
void leximi();
void shtypja();
};
void inicimi::leximi()
{
cout << "Jep nje vlere per variablen: ";
cin >> variabla;
}
void inicimi::shtypja()
{
cout<< "Variabla e dhënë përmes funksionit leximi: "
<< variabla << "\n";
}
int main()
{
inicimi objekti;
objekti.leximi();
objekti.shtypja();
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
97
90. Të krijohet klasa me emrin inicimi_direkt e cila përmban tri variabla
publike të cilat do të inicohen gjatë deklarimit të objektit të klasës. Më
pas, përmes funksionit shtypja të shtypen vlerat e variablave.
#include<iostream>
using namespace std;
class inicimi_direkt
{
public:
int x1,x2;
double y;
void shtypja();
};
void inicimi_direkt::shtypja()
{
cout << "\nVlera e x1="
<< x1
<< "\nVlera e x2="
<< x2
<< "\nVlera e y="
<< y
<< "\n\n";
}
int main()
{
inicimi_direkt ini_d={16,4,20.13};
ini_d.shtypja();
system("pause");
return 0;
}
91. Të shkruhet programi, përmes të cilit krijohet klasa data në
komponentët e së cilës paraqitet variablat private, p_dita, p_muaji dhe
p_viti si dhe prototipat e funksioneve për vendosje dhe lexim të ditës,
muajit dhe vitit. Funksionet për vendosje dhe lexim të datës të
implementohen jashtë klasës data. Në funksionin main të deklarohet një
objekt i klasës dhe të shtypet një datë e caktuar.
#include <iostream>
using namespace std;
class data
{
private: //variablat private
int p_dita;
int p_muaji;
int p_viti;
public:
int l_dita();
int l_muaji();
int l_viti();
void muaji(int);

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
98
void dita(int);
void viti(int);
};
int data::l_dita(){return p_dita;}
int data::l_muaji(){return p_muaji;}
int data::l_viti(){return p_viti;}
void data::muaji(int f_muaji)
{
p_muaji=f_muaji;
};
void data::dita(int f_dita)
{
p_dita=f_dita;
};
void data::viti(int f_viti)
{
p_viti=f_viti;
};
int main()
{
data dt;
//vendosa e vlerave
dt.dita(27);
dt.muaji(2);
dt.viti(2008);
//leximi i vlerave
cout << dt.l_dita() << "."
<< dt.l_muaji() << "."
<< dt.l_viti() << endl;
system("pause");
return 0;
}
5.7. Shfrytëzimi i vlerave të variablave private
Qasja direkte në variablat private të klasës nuk lejohet. Për shfrytëzimin e
tyre, duhet të krijohen funksione të veçanta brenda klasës, të deklaruara si
publike. Këto funksione mund të jenë: pa parametra formalë ose me parametra
referentë.
92. Të shkruhet programi në të cilin krijohet klasa artikulli. Klasa
artikulli si anëtarë privat e ka variablen kodi, kurse si anëtarë publik i
ka funksionet leximi, shtypja dhe funksionin merr_vleren i cili e merr
vlerën e anëtarit privat dhe e ruan tek një variabël jashtë klasës.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
99
#include <iostream>
using namespace std;
class artikulli
{
int kodi;
public :
void leximi();
void shtypja();
int merr_vleren();
};
void artikulli::shtypja()
{
cout << "Kodi="
<< kodi << "\n\n";
}
void artikulli::leximi()
{
cout << "Jep vlerën e kodit: ";
cin >> kodi;
}
int artikulli::merr_vleren()
{
return kodi;
}
int main()
{
int k;
artikulli art;
art.leximi();
k=art.merr_vleren();
cout<<"Vlera e kodit është ruajtur tek k-ja; k="
<< k << "\n";
art.shtypja();
system("pause");
return 0;
}
93. Të modifikohet shembulli paraprak dhe funksioni merr_vleren të ketë si
parametër referent variablen e deklaruar jashtë klasës.
#include <iostream>
using namespace std;
class artikulli
{
int kodi;
public :
void leximi();
void shtypja();
int merr_vleren(int& k);
};
void artikulli::shtypja()

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
100
{
cout << "Kodi="
<< kodi << "\n\n";
}
void artikulli::leximi()
{
cout << "Jep vlerën e kodit: ";
cin >> kodi;
}
int artikulli::merr_vleren(int& k)
{
return kodi;
}
int main()
{
int k;
artikulli art;
art.leximi();
k=art.merr_vleren(k);
cout<<"Vlera e kodit është ruajtur tek k-ja; k="
<< k << "\n";
art.shtypja();
system("pause");
return 0;
}
5.8. Llogaritjet me variabla të klasës
Variablat që paraqiten në anëtarët e klasës mund të shfrytëzohen për
llogaritje të ndryshme. Shfrytëzimi i variablave të klasës varet nga ajo se a
janë deklaruar anëtarët përkatës si publik ose privat. Nëse anëtarët e klasës
janë publik, mund të shfrytëzohen duke e shënuar para tyre emrin e objektit
përkatës dhe pikën. Nëse anëtarët e klasës janë privat, ata mund të
shfrytëzohen vetëm përmes funksioneve brenda klasës.
94. Të shkruhet programi në të cilin krijohet klasa llogaritja për
llogaritjen e shprehjes së mëposhtme. Variabla n është private, kurse
variabla m është publike.
#include <iostream>
using namespace std;
class llogaritja
{
private:
int n;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
101
public:
int m;
void leximi();
void shtypja();
int merr_vleren();
};
int main()
{
int p;
double y=0;
llogaritja llog;
llog.leximi();
cout << "Jep vleren e variables publike m: ";
cin >> llog.m;
llog.shtypja();
p=llog.merr_vleren();
for (int i=0;i<=(llog.m+p);i++)
y=y+(3*i+2*p);
y=llog.m+y;
cout<< "\nVlera e funksionit y="
<< y << "\n\n";
system("pause");
return 0;
}
void llogaritja::leximi()
{
cout << "Jep vleren e variables private n: ";
cin >> n;
}
void llogaritja::shtypja()
{
cout<< "\nVlera e variables private n="<< n
<< "\nVlera e variables publike m=" << m
<< "\n";
}
int llogaritja::merr_vleren()
{
return n;
}
5.9. Shfrytëzimi i funksioneve brenda klasës
Funksionet mund të paraqiten në pjesën publike ose private të klasës. Nëse
funksionet janë përfshirë tek pjesa publike, shfrytëzimi i tyre si brenda,
ashtu edhe jashtë klasës nuk ka asnjë kufizim. Mirëpo një funksion i cili
është anëtar privat, mund të thirret vetëm nga një tjetër funksion i cili
është anëtar i së njëjtës klasë. Funksioni privat nuk mund të thirret përmes
objektit dhe operatorit pikë (.)

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
102
95. Të modifikohet shembulli paraprak dhe shprehja e mëposhtme të
llogaritet duke shfrytëzuar funksionin publik shuma i cili është brenda
klasës llogaritja.
#include <iostream>
using namespace std;
class llogaritja
{
private:
int n;
public:
int m;
void leximi();
void shtypja();
double shuma(int m, int n);
int merr_vleren();
};
int main()
{
int p;
double y=0;
llogaritja llog;
llog.leximi();
cout << "Jep vleren e variables publike m: ";
cin >> llog.m;
llog.shtypja();
p=llog.merr_vleren();
y=llog.m+llog.shuma(llog.m,p);
cout<< "\nVlera e funksionit y="
<< y << "\n\n";
system("pause");
return 0;
}
double llogaritja::shuma(int m, int n)
{
double s=0;
for (int i=0;i<=(m+n);i++)
s=s+(3*i+2*n);
return s;
}
void llogaritja::leximi()
{
cout << "Jep vlerën e variablës private n: ";
cin >> n;
}
void llogaritja::shtypja()
{

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
103
cout<< "\nVlera e variablës private n="<< n
<< "\nVlera e variablës publike m=" << m
<< "\n";
}
int llogaritja::merr_vleren()
{
return n;
}
96. Të modifikohet shembulli paraprak dhe shprehja e mëposhtme të
llogaritet duke shfrytëzuar funksionin privat shuma i cili është brenda
klasës llogaritja.
#include <iostream>
using namespace std;
class llogaritja
{
private:
int n,m;
double shuma(int m, int n);
public:
void leximi();
void shtypja();
double thirr_shumen();
};
int main()
{
int p;
double y=0;
llogaritja llog;
llog.leximi();
y=llog.thirr_shumen();
llog.shtypja();
cout<< "\nVlera e funksionit y="
<< y << "\n\n";
system("pause");
return 0;
}
double llogaritja::thirr_shumen()
{
return shuma(m,n);
}
double llogaritja::shuma(int m, int n)
{
double s=0;
for (int i=0;i<=(m+n);i++)
s=s+(3*i+2*n);
return m+s;
}
void llogaritja::leximi()
{
cout << "Jep vlerën e variablës m dhe n: ";

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
104
cin >> m>>n;
}
void llogaritja::shtypja()
{
cout<< "\nVlera e variablës n="<< n
<< "\nVlera e variablës m="<< m
<< "\n";
}
97. Të shkruhet programi në të cilin krijohet klasa llogaritja për
llogaritjen e shprehjes së mëposhtme. Llogaritja e shprehjes të kryhet
përmes një funksioni publik të quajtur shuma i cili është brenda klasës
llogaritja. Variabla n është private, kurse variabla m është publike.
#include <iostream>
using namespace std;
class llogaritja
{
private:
int n;
public:
int m;
void leximi();
void shtypja();
double shuma(int a, int b, int c, int d );
int merr_vleren();
};
int main()
{
int p;
double y=0;
llogaritja llog;
llog.leximi();
cout << "Jep vleren e variables publike m: ";
cin >> llog.m;
llog.shtypja();
p=llog.merr_vleren();
y=llog.m+llog.shuma(0,llog.m+p,3,2) + llog.shuma(3,llog.m,1,0);
cout<< "\nVlera e funksionit y="
<< y << "\n\n";
system("pause");
return 0;
}
double llogaritja::shuma(int a, int b, int c, int d)
{
double s=0;
for (int i=a;i<=b;i++)

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
105
s=s+(c*i+d);
return s;
}
void llogaritja::leximi()
{
cout << "Jep vlëren e variables private n: ";
cin >> n;
}
void llogaritja::shtypja()
{
cout<< "\nVlera e variablës private n="<< n
<< "\nVlera e variablës publike m=" << m
<< "\n";
}
int llogaritja::merr_vleren()
{
return n;
}
98. Të shkruhet programi në të cilin krijohet klasa llogaritja për
llogaritjen e shprehjes së mëposhtme. Llogaritja e shprehjes të kryhet
përmes një funksioni privat të quajtur prodhimi i cili është brenda klasës
llogaritja. Variabla n është private.
#include <iostream>
using namespace std;
class llogaritja
{
private:
int n;
double prodhimi();
public:
void vendos_vlerat();
void shtypja();
double thirr_prodhimin();
};
int main()
{
double y=0;
llogaritja llog;
llog.vendos_vlerat();
y=llog.thirr_prodhimin();
llog.shtypja();
cout<< "\nVlera e funksionit y="
<< y << "\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
106
double llogaritja::prodhimi()
{
double p=1;
for (int i=1;i<=n;i++)
p=p*(2*i);
return p;
}
void llogaritja::vendos_vlerat()
{
cout << "Jep vleren e variablës n: ";
cin >> n;
}
double llogaritja::thirr_prodhimin()
{
return prodhimi();
}
void llogaritja::shtypja()
{
cout<< "\nVlera e variablës n ="<< n
<< "\n";
}
99. Të shkruhet programi në të cilin krijohet klasa FormatiDates. Klasa të
ketë anëtarët për mbajtjen e ditës, muajit dhe vitit si dhe funksionet për
vendosjen dhe marrjen e këtyre vlerave. Të deklarohet disa objekte të
klasës dhe përmes konstruktorit të thirret funksioni për vendosjen e
datës. Nëse data është gabim të vendoset në 1.1.1900. Funksioni për
shfaqjen/shtypjen e datës të ketë disa opsione të shtypjes si p.sh
dd.mm.vvv, dd/mm/vvvv etj.
#include <iostream>
#include <string>
using namespace std;
class FormatiDates
{
private:
int muaji;
int dita;
int viti;
public:
void vendosDaten(int d, int m, int v);
int merrDiten();
int merrMuajin();
int merrVitin();
void shfaqDaten(string formati);
FormatiDates(int m = 1, int d = 1, int v = 1900);
bool vitiBrishte(int);
};
void FormatiDates::vendosDaten(int d,int m, int v)
{
bool gabim=false;
int shkurt=28;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
107
switch(m)
{
//muaji 1, 3, 5, 7, 8, 10, 12 i kanë nga 31 ditë
case 1 :
case 3 :
case 5 :
case 7 :
case 8 :
case 10:
case 12:
if (d > 31)
gabim=true;
break;
case 4 : //muaji 4, 6, 9 dhe 11 i kanë nga 30 ditë
case 6 :
case 9 :
case 11:
if (d > 30)
gabim=true;
break;
case 2 : //muaji 2 i ka 28 ose 29 ditë
if(vitiBrishte(v))
shkurt=29;
if(d>shkurt)
gabim=true;
}
if(gabim)
{
cout<<"Data "<<d<<"/"<<m<<"/"<<v<<" është jo valide. Do të përdoret
1/1/1900\n";
d=1;
m=1;
v=1900;
}
dita = d;
muaji = m;
viti = v;
}
bool FormatiDates::vitiBrishte(int v)
{
if((v%4==0 && v!=0)|| v==0)
return true;
return false;
}
int FormatiDates::merrDiten()
{
return dita;
}
int FormatiDates::merrMuajin()
{
return muaji;
}
int FormatiDates::merrVitin()
{
return viti;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
108
void FormatiDates::shfaqDaten(string formati)
{
if (formati=="dd.mm.vvvv")
cout << dita << "." << muaji << "." << viti;
else if(formati=="mm.dd.vvvv")
cout << muaji << "." << dita << "." << viti;
else if(formati=="dd/mm/vvvv")
cout << dita << "/" << muaji << "/" << viti;
else if(formati=="dd-mm-vvvv")
cout << dita << "-" << muaji << "-" << viti;
else
cout << dita << "/" << muaji << "/" << viti;
}
FormatiDates::FormatiDates(int d,int m, int v)
{
vendosDaten(d, m, v);
}
int main()
{
FormatiDates d1(29,2,2010);
cout<<"Data e parë: ";
d1.shfaqDaten("dd.mm.vvvv");
cout<<endl;
FormatiDates d2(17,02,2008);
cout<<"Data e dytë: ";
d2.shfaqDaten("dd/mm/vvvv");
cout<<endl;
system("pause");
return 0;
}
5.10. Konstruktorët
Konstruktori është një funksion anëtar i cili inicion variablat në brendësi
të klasës. Konstruktori mënjanon nevojën e inicimit të variablave sa herë që
krijohet një objekt i ri. Konstruktori e ka emrin e njëjtë si vetë klasa por
nuk ka tip kthyes. Konstruktori thirret automatikisht sa herë që krijohet një
instancë e klasës. Nëse nuk krijohet konstruktori, kompajleri do ta krijojë
një në mënyrë automatike (default) i cili do t’i iniciojë variablat e klasës
në vlerën null.
5.10.1. Konstruktorët pa parametra formalë
Konstruktorët mund të mos kenë parametra formalë, nëse përcaktimi i vlerave
të variablave në anëtarët privat bëhet brenda konstruktorëve.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
109
100. Të shkruhet programi përmes së cilit llogaritet sipërfaqja s dhe
perimetri p i rrethit me rreze r. Për inicimin e konstantes pi, brenda
klasës rrethi, e cila krijohet në program të shfrytëzohet konstruktori
përkatës i klasës.
#include <iostream>
using namespace std;
class rrethi
{
private:
double pi,r,s,p;
public:
rrethi(); //konstruktori
void rrezja(double x);
void llogaritja();
void shtypja();
};
int main()
{
rrethi rr;
double x;
cout << "\nRrezja e rrethit x: ";
cin >> x;
rr.rrezja(x);
rr.llogaritja();
rr.shtypja();
system("pause");
return 0;
}
rrethi::rrethi() //thirret gjate deklarimit te instances se klases
{
pi=3.1415926;
}
void rrethi::rrezja(double x)
{
r=x;
}
void rrethi::llogaritja()
{

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
110
s=pi*r*r;
p=2*pi*r;
}
void rrethi::shtypja()
{
cout<< "\nSiperfaqja s="<<s
<< "\n\nPerimetri p="<<p<< "\n";
}
5.10.2. Konstruktorët me parametra formalë
Konstruktori (default) nuk ka parametra, por nëse nevojiten ai mund të ketë.
Kjo ndihmon për inicimin e vlerave gjatë kohës së deklarimit të një instance
të re (objekti).
101. Të modifikohet shembulli paraprak dhe për inicimin e konstantes pi dhe
rrezes r të përdoret konstruktori me rrezen e rrethit si parametër formal.
#include <iostream>
using namespace std;
class rrethi
{
private:
double pi,r,s,p;
public:
rrethi(double x); //konstruktori me parametra formale
void llogaritja();
void shtypja();
};
int main()
{
double x;
cout << "\nRrezja e rrethit x: ";
cin >> x;
rrethi rr(x);
rr.llogaritja();
rr.shtypja();
system("pause");
return 0;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
111
}
rrethi::rrethi(double x) //thirret gjate deklarimit te instances se klases
{
pi=3.1415926;
r=x;
}
void rrethi::llogaritja()
{
s=pi*r*r;
p=2*pi*r;
}
void rrethi::shtypja()
{
cout<< "\nSiperfaqja s="<<s
<< "\nPerimetri p="<<p<< "\n";
}
102. Të shkruhet programi dhe të krijohet klasa NumratKompleks për mbledhjen
dhe zbritjen e numrave kompleks. Vendosja e pjesës reale dhe imagjinare të
mundësohet përmes konstruktorit me dy parametra si dhe përmes funksionit
vendosNumrin i cili ka parametra pjesën reale dhe imagjinare të numrit
kompleks. Në funksionin main të kryhet mbledhja për dy numra të vendosur
përmes konstruktorit, kurse zbritja të kryhet përmes dy numrave të
vendosur përmes funksionit vendosNumrin.
#include <iostream>
using namespace std;
class NumratKompleks
{
private:
double Reale;
double Imagjinare;
public:
NumratKompleks(double = 0.0, double = 0.0);
void mbledhja(NumratKompleks &a );
void zbritja(NumratKompleks &a );
void shtyp();
void vendosNumrin(double r, double i);
};
NumratKompleks::NumratKompleks(double reale, double imagjinare)
{
vendosNumrin(reale, imagjinare);
}
void NumratKompleks::mbledhja(NumratKompleks &a)
{
Reale += a.Reale;
Imagjinare += a.Imagjinare;
}
void NumratKompleks::zbritja(NumratKompleks &s)
{

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
112
Reale -= s.Reale;
Imagjinare -= s.Imagjinare;
}
void NumratKompleks::shtyp()
{
cout << '(' << Reale << ", " << Imagjinare << ')';
}
void NumratKompleks::vendosNumrin(double r, double i )
{
Reale = r;
Imagjinare = i;
}
int main()
{
//përmes konstruktorit
NumratKompleks nr1(2, 7.5), nr2(4.2, 2.3 );
nr1.shtyp();
cout << " + ";
nr2.shtyp();
cout << " = ";
nr1.mbledhja(nr2);
nr1.shtyp();
cout << '\n';
//përmes funksionit vendosNumrin
nr1.vendosNumrin(10, 1.5);
nr2.vendosNumrin(8.5, 5);
nr1.shtyp();
cout << " - ";
nr2.shtyp();
cout << " = ";
nr1.zbritja( nr2 );
nr1.shtyp();
cout << endl;
system("pause");
return 0;
}
5.11. Llogaritjet brenda konstruktorëve
Përveç inicimit të variablave, brenda konstruktorëve mund të kryhen edhe
llogaritje të ndryshme. Rezultatet e llogaritjeve duhet të përcillen/ruhen
tek variablat e përfshira në anëtarët e klasave.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
113
103. Të shkruhet programi në të cilin krijohet klasa llogaritja. Variablat m
dhe n të deklarohen si private, kurse rezultati i shprehjes të ruhet në
variablen publike y. Për inicimin e variablave m dhe n dhe llogaritjen e
shprehjes së mëposhtme të përdoret konstruktori i klasës.
#include <iostream>
using namespace std;
class llogaritja
{
private:
int m, n;
public:
double y;
void shtypja();
llogaritja(); //konstruktori
};
int main()
{
int p;
double y=0;
llogaritja llog;
llog.shtypja();
system("pause");
return 0;
}
void llogaritja::shtypja()
{
cout<< "\nVlera e variables m="<< m
<< "\nVlera e variables n=" << n
<< "\nVlera e funksionit y="<<y
<<"\n";
}
llogaritja::llogaritja()
{

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
114
cout << "Jep vleren e variables m dhe n: ";
cin >> m >>n;
double s=0;
for (int i=0;i<=(m+n);i++)
s=s+(3*i+2*n);
y=m+s;
}
104. Të shkruhet programi përmes së cilit krijohet klasa thjeshte. Duke
shfrytëzuar konstruktorin e klasës i cili ka një parametër formal të
kontrollohet nëse numri i dhënë është numër i thjeshtë.
#include<iostream>
using namespace std;
class thjeshte
{
int nr,i;
bool r;
public:
thjeshte(int x)
{
nr=x;
for(i=2;i<=nr/2;i++)
if(nr%i==0)
{
r=false;
break;
}
else
{
r=true;
}
}
void shtyp()
{
if(r==true)
cout<<"\n"<<nr<<" është numër i thjeshtë.";
else
cout<<"\n"<<nr<<" nuk është numër i thjeshtë.";
cout<<endl;
}
};
int main()
{
int a;
cout<<"Sheno nje numer te plote:";
cin>>a;
thjeshte obj(a);
obj.shtyp();
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
115
5.12. Disa konstruktorë njëkohësisht
Klasa mund të ketë më shumë se një konstruktor, por konstruktorët duhet të
kenë listë të ndryshme të parametrave formalë. Kjo mundësohet duke përdorur
metodën e mbingarkimit.
105. Të shkruhet programi në të cilin krijohet klasa faktorieli dhe
llogariten vlerat e funksioneve të mëposhtme duke shfrytëzuar dy
konstruktorë.
#include <iostream>
using namespace std;
class faktorieli
{
private:
int m;
double x;
public:
double g;
faktorieli();
faktorieli(int k);
};
int main()
{
faktorieli fa1;
cout << "Vlera e llogaritur y="
<< fa1.g;
faktorieli fa2(3);
cout << "Vlera e llogaritur z="
<< fa2.g << "\n\n";
system("pause");
return 0;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
116
}
faktorieli::faktorieli()
{
m=3;
cout << "Konstruktori i parë"
<< "\n-------------------"
<< "\nVariabla x: ";
cin >> x;
double F=1;
int i;
for (i=1;i<=m;i++)
F=F*i;
g=5*x+F;
}
faktorieli::faktorieli(int k)
{
m=k;
cout << "\n\nKonstruktori i dytë"
<< "\n-------------------"
<< "\nVariabla x: ";
cin >> x;
double F=1;
int i;
for (i=1;i<=(m+1);i++)
F=F*i;
g=x/2+F;
}
5.13. Destruktorët
Destruktori zakonisht përdoret për lirimin e memories e cila është rezervuar
gjatë deklarimit të objekteve. Emri i destruktorit është i njëjtë me emrin e
klasës, por para tij vendoset simboli ~ (lexo: tilda). Klasa mund të ketë
vetëm një destruktor. Destruktori nuk ka asnjë parametër dhe nuk ka tip
kthyes.
106. Të shkruhet programi, dhe të krijohet klasa vlera e cila përmban
funksionet publike për vendosjen dhe marrjen e vlerës së numrit. Numri
është variabël private. Të implementohet konstruktori dhe destruktori i
klasës në të cilin tregohet se kur po thirret konstruktori dhe kur
destruktori.
#include<iostream>

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
117
using namespace std;
class vlera
{
int numri;
public:
void vendos_numrin(int num);
int merr_numrin();
vlera() //konstruktori
{
cout<<"\nKonstruktori eshte thirrur \n";
}
~vlera() //destruktori
{
cout<<"\nDestruktori eshte thirrur \n";
system("pause");
}
};
void vlera::vendos_numrin(int nr)
{
numri = nr;
}
int vlera::merr_numrin()
{
return numri;
}
int main()
{
int nr = 2013;
vlera obj;
obj.vendos_numrin(nr);
nr = obj.merr_numrin();
cout<<"\nNumri eshte = "<<nr<<endl;
system("pause");
return 0;
}
5.14. Trashëgimia
Trashëgimia është tipar shumë i rëndësishëm në programimin e orientuar në
objekte dhe nënkupton ripërdorimin e kodit të krijuar më herët. Me fjalë të
tjera trashëgimia është një mekanizëm i ripërdorimit dhe i zgjerimit të
klasës ekzistuese pa e modifikuar atë, duke prodhuar marrëdhënie hierarkike
midis klasës ekzistuese dhe klasës së re. Pra, përmes trashëgimisë (ang.
inheritance), anëtarët e klasës ekzistuese mund të shfrytëzohen për krijimin
e klasës së re. Çdo klasë e re trashëgon gjendjen dhe metodat nga klasa prej
së cilës është krijuar. Klasa ekzistuese njihet si klasë bazë (ang. Base
class), kurse klasa e re e cila i trashëgon karakteristikat e klasës bazë,
quhet klasa e derivuar (ang. Derived class). Skema e mëposhtme paraqet një
hierarki të trashëgimisë së klasave.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
118
Klasat e derivuara, përveç variablave dhe metodave të trashëguara, mund të
kenë edhe variabla dhe metoda të reja. C + + përkrah lloje të ndryshme të
trashëgimisë e të cilat janë:
1. Trashëgimia e vetme
2. Trashëgimia me shumë nivele
3. Trashëgimia e shumëfishtë
4. Trashëgimia hierarkike
5. Trashëgimia hibride
Trashëgimia e vetme është kur ekziston vetëm një klasë bazë dhe një klasë e
derivuar të cilat kanë një komunikim një me një.
Trashëgimisë me shumë nivele është kur një klasë e derivuar mund të
trashëgohet edhe nga një klasë tjetër dhe kështu krijohet nivel i
shumëfishtë.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
119
Trashëgimia e shumëfishtë është kur klasa e derivuar trashëgon tiparet nga dy
ose më shumë klasa bazë. Në këtë lloj trashëgimie mund të ketë paqartësi kur
më shumë se një klasë përmban një funksion me të njëjtin emër.
Trashëgimia hierarkike është kur klasa bazë ka shumë klasa të derivuara ose
kur klasa bazë është përdorur ose trashëguar nga shumë klasa të derivuara.
Trashëgimia hibride është një përzierje e dy ose më shumë trashëgimive në një
trashëgimi të vetme.
Forma e përgjithshme e sintaksës për klasën e derivuar është:
Skema e mëposhtme paraqet një shembull të trashëgimisë, ku klasa rrethi është
trashëguar nga klasa figurat. Pra rrethi është klasa e derivuar, kurse
figurat është klasa bazë.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
120
107. Të shkruhet programi në të cilin krijohet klasa bazë KlasaBaze dhe
klasa e derivuar KlasaDerivuar. Klasa bazë përmban një variabël private
dhe një publike si dhe funksionin për shtypjen e vlerave të këtyre
variablave. Klasa e derivuar përmban një variabël private dhe një publike
si dhe funksionin për shtypjen e vlerave të variablave të klasës së
derivuar dhe variablës publike të klasës bazë.
#include <iostream>
using namespace std;
class KlasaBaze
{
private:
int a;
public:
double b;
void shtyp_baze()
{
a=5;
b=8;
cout<< "Vlerat e klasës bazë"
<< "\na="<< a
<< "\nb="<< b
<< "\n\n";
}
};
class KlasaDerivuar:public KlasaBaze
{
private:
double c;
public:
int d;
void shtyp_derivuar()
{
b=2; //variabel e klasës bazë
c=4;
d=7;
cout << "Vlerat e klasës së derivuar"
<< "\nb = "<< b
<< "\nc = "<< c
<< "\nd = "<< d
<< "\n\n";
}
};
int main()
{
KlasaBaze kb; KlasaDerivuar kd;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
121
kb.shtyp_baze();
kd.shtyp_derivuar();
system("pause");
return 0;
}
108. Të shkruhet programi në të cilin krijohet klasa bazë Veturat dhe klasa
e derivuar VeturePolicie. Klasa bazë përmban një variabël private për
shpejtësinë dhe funksionet publike për vendosjen dhe marrjen e
shpejtësisë. Klasa e derivuar përmban shpejtësinë aktuale dhe nëse vetura
është në aksion. Të vendosen vlerat për shpejtësinë, shpejtësinë aktuale
dhe nëse vetura është në aksion dhe me pas të shtypen vlerat.
#include <iostream>
using namespace std;
class Veturat
{
private:
int shpejtesia;
public:
void v_shpejtesine(int sh)
{
shpejtesia=sh;
}
int m_shpejtesine()
{
return shpejtesia;
}
};
class VeturePolicie : public Veturat
{
private:
int shpejtesiAktuale;
bool aksion;
public:
void v_shpejtAktuale(int a)
{
shpejtesiAktuale=a;
}
int m_shpejtAktuale()
{
return shpejtesiAktuale;
}
void v_neAksion(bool a)
{
aksion=a;
}
bool m_neAksion()
{
return aksion;
}
};
int main()
{

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
122
Veturat kb; VeturePolicie kd;
kb.v_shpejtesine(260);
kd.v_shpejtAktuale(180);
kd.v_neAksion(true);
if (kd.m_neAksion()==true)
cout<<"Vetura e policisë është në aksion\n "
<<"dhe po leviz me shpejtesi "
<<kd.m_shpejtAktuale()
<<"/" <<kb.m_shpejtesine();
else
cout<<"Vetura e policisë është në aksion\n"
<<"dhe po leviz me shpejtësi "
<<kd.m_shpejtAktuale()
<<"/" <<kb.m_shpejtesine();
cout<<endl;
system("pause");
return 0;
}
109. Të shkruhet programi në të cilin krijohen klasat pajisjeUSB dhe
pajisjeRrjeti të cilat kanë nga një anëtar privat me të njëjtin emër dhe
nga një funksion publik me të njëjtin emër për leximin e vlerës së
variablës private. Secila klasë të ketë edhe konstruktorin për vendosjen e
vlerës së variablës private. Të krijohet klasa pajisje_wireless e cila
trashëgohet nga klasat pajisjeUSB dhe pajisjeRrjeti, pra trashëgimi e
shumëfishtë. Tek funksioni main të deklarohet objekti i klasës së derivuar
dhe të thirret funksioni për leximin e vlerës së variablës private. Cili
funksion do të thirret?
#include <iostream>
using namespace std;
class pajisjeUSB
{
private:
long a_ID;
public:
pajisjeUSB(long id)
: a_ID(id)
{
}
long m_ID()
{
return a_ID;
}
};
class pajisjeRrjeti
{
private:
long a_ID;
public:
pajisjeRrjeti(long id)
: a_ID(id)

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
123
{
}
long m_ID()
{
return a_ID;
}
};
class pajisje_wireless: public pajisjeUSB, public pajisjeRrjeti
{
public:
pajisje_wireless(long usb_id, long net_id)
: pajisjeUSB(usb_id), pajisjeRrjeti(net_id)
{
}
};
int main()
{
pajisje_wireless RJ45(12345678, 87654321);
//cout << RJ45.m_ID(); // Cila m_ID() do të thirret?
cout << RJ45.pajisjeUSB::m_ID();
cout<<endl;
cout << RJ45.pajisjeRrjeti::m_ID();
system("pause");
return 0;
}
5.15. Anëtarët statik të klasës
Deri me tani u pa se se secili objekt i klasës i ka kopjet e veta të veqanta
për të gjithë anëtarët e klasës. Megjithatë ekziston një përjashtim ku vetëm
një variabël e caktuar mund të jetë e përbashkët për të gjitha objektet e
klasës. Për këtë arsye përdoret një anëtarë statik dhe të gjitha objektet e
klasës kanë vetëm një instancë të këtij anëtari. Anëtari statik i klasës mund
të thirret edhe pa u krijuar një objekt i klasës. Siç shihet edhe nga skema e
mëposhtme janë deklaruar dy objekte ob1 dhe ob2 dhe të dy objektet kanë
kopjet e veqanta për anëtarin Y, ob1 ka vlerën 10, kurse ob2 ka vlerën 20.
Mirëpo anëtari X është i përbashkët për të dy objektet, pra është vetëm një
instancë dhe vlera e këtij anëtari është 5 për të dyja objektet.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
124
Në bazë të kësaj mund të thuhet se një anëtar statik paraqet apo ruan
informacion të gjërë i cili informacion është i përbashkët për të gjitha
instancat dhe nuk është specifik për secilin objekt.
110. Të shkruhet programi në të cilin krijohet klasa AnetarStatik me
anëtarët privat rendi dhe anëtarin statik numeruesi. Përmes konstruktorit
të nënkuptuar, të rritet numëruesi për një sa herë që krijohet një objekt
i klasës dhe të shtypet vlera e numëruesit përmes variablës rendi e cila
lexohet përmes funksionit lexoRendi.
#include <iostream>
using namespace std;
class AnetarStatik
{
private:
static int numeruesi;
int rendi;
public:
AnetarStatik()
{
rendi = numeruesi++;
}
int merrRendi()
{
return rendi;
}
};
int AnetarStatik::numeruesi = 1;
int main()
{
AnetarStatik ob1;
AnetarStatik ob2;
AnetarStatik ob3;
cout <<"Objekti "<< ob1.merrRendi()
<<"\nObjekti "<< ob2.merrRendi()

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
125
<<"\nObjekti "<< ob3.merrRendi()
<< endl;
system("pause");
return 0;
}
111. Të shkruhet programi në të cilin krijohet klasa kursimet për
llogaritjen e kamatës për paratë e kursyera në llogarinë e kursimeve.
Interesi vjetor të ruhet në variablën statike në menyrë që të jetë i njëtë
për të gjithë klientët. Të deklarohen dy klient të cilët vendosin shuma të
ndryshme të parave në llogarinë e kursimeve dhe më pas të llogaritet
interesi për 12 muaj duke e shtypur rezultatin për secilin muaj.
#include <iostream>
#include <iomanip>
using namespace std;
class kursimet
{
private:
double bilanciKursimeve;
static double InteresiVjetor;
public:
kursimet(double fillestare)
{
//nëse gjendja fillestare eshte me e vogel se zero vendose 0.
bilanciKursimeve = fillestare >= 0 ? fillestare : 0;
}
void interesiMujor();
static void ndryshoInteresinMujor( double );
void shfaqBilancin() ;
};
double kursimet::InteresiVjetor = 0.0;
void kursimet::interesiMujor()
{
bilanciKursimeve += bilanciKursimeve * ((InteresiVjetor/100)/12.0 );
}
void kursimet::ndryshoInteresinMujor( double interesi )
{
//nëse interesi është më I madh se 1.75% vendose ne 1.5
InteresiVjetor = ( interesi >= 0 && interesi <= 1.75 ) ? interesi : 1.5;
}
void kursimet::shfaqBilancin( void )
{
cout << fixed <<showpoint
<< setprecision(2) << bilanciKursimeve
<< fixed <<showpoint ;
}
int main()
{
char v[]="\n------------------------------------------------------------\n";
kursimet::ndryshoInteresinMujor(1.5); //inicimi para se të krijohen objektet

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
126
kursimet klienti1(1000), klienti2(1500); //krijimi i dy objekteve
cout << "\nBilancet mujore për kursimet me interesi 1.5%"
<<v
<< "Bilanci fillestar i kursimeve: \nKlienti 1 ";
klienti1.shfaqBilancin();
cout << "\t\nKlienti 2 ";
klienti2.shfaqBilancin();
cout<<v;
for (int muaji = 1; muaji <= 12; ++muaji )
{
klienti1.interesiMujor();
klienti2.interesiMujor();
cout << "\nMuaji" << setw(3) << muaji << "| Klienti 1: ";
klienti1.shfaqBilancin();
cout << "\t||\tKlienti 2: ";
klienti2.shfaqBilancin();
}
cout<<v;
system("pause");
return 0;
}
5.16. Shfrytëzimi i anëtarëve të mbrojtur –
protected
Nëse dëshirohet që anëtarët privat të klasës bazë të përdoren edhe në klasën
e derivuar, atëherë këta anëtarë duhet të deklarohen si protected. Anëtarëve
të deklaruar si protected nuk mund të iu qaset nga jashtë klasës, por mund të
iu qaset nga një klasë e derivuar.
112. Të shkruhet programi në të cilin krijohet klasa bazë figura dhe klasa e
derivuar drejtkendeshi. Klasa bazë përmban anëtarët e mbrojtur gjatesia
dhe lartesia si dhe funksionet për vendosjen e këtyre vlerave. Në klasën
e derivuar të llogaritet sipërfaqja e drejtkëndëshit, kurse në funksionin
kryesor të krijohet objekti i klasës drejtkendeshi dhe të shtypet vlera e
sipërfaqes.
#include <iostream>
using namespace std;
class figura //Klasa bazë
{
protected:
int gjatesia;
int lartesia;
public:
void v_gjatesine(int g)
{
gjatesia = g;
}
void v_lartesine(int h)

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
127
{
lartesia = h;
}
};
class drejtkendeshi: public figura //Klasa e derivuar
{
public:
int m_siperfaqe()
{
return (gjatesia * lartesia);
}
};
int main()
{
drejtkendeshi drejt;
drejt.v_gjatesine(5);
drejt.v_lartesine(7);
cout << "Siperfaqja: "
<< drejt.m_siperfaqe()
<< endl;
system("pause");
return 0;
}
113. Të shkruhet programi në të cilin krijohet klasa bazë trajnimet dhe
klasa e derivuar topTrajnimi. Klasa bazë përmban anëtarët e mbrojtur id
dhe emri të tipit string si dhe funksionet për vendosjen e këtyre vlerave.
Në klasën e derivuar është një anëtar privat me emrin vleresimi i tipit
int dhe funksioni shtyp për shtypjen e vlerave të id-së, emrit dhe
vlerësimit. Në funksionin main të krijohet një objekt i klasës së
derivuar, të vendosen vlerat dhe me pas të shtypen këto vlera.
#include <iostream>
#include <string>
using namespace std;
class trajnimet
{
protected:
string id;
string emri;
public:
void v_id(string id1)
{
id=id1;
}
void v_emrin(string emri1)
{
emri=emri1;
}
};
class topTrajnimi : public trajnimet

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
128
{
private:
int vleresimi;
public:
void v_vleresimin(int vlera)
{
vleresimi=vlera;
}
void shtyp()
{
cout<<"Kursi me i vleresuar\n"
<<"ID: "<<id
<<"\nEmri: "<<emri
<<"\nVleresimi: "<<vleresimi <<"\n";
}
};
int main()
{
topTrajnimi top1;
top1.v_id("ASDh2013");
top1.v_emrin("Algoritmet dhe Struktura e të Dhenave");
top1.v_vleresimin(5);
top1.shtyp();
system("pause");
return 0;
}
5.17. Shfrytëzimi i anëtarëve gjatë trashëgimisë
Shfrytëzimi i anëtarëve gjatë trashëgimisë mund të bëhet si public, protected
dhe private. Nëse nuk përcaktohet specifikuesi i qasjes, atëherë merret si
private. Skema e mëposhtme paraqet mënyrat e trashëgimisë.
Trashëgimia publike është metoda më e praktikuar, prandaj është më rëndësi që
kjo metodë të kuptohet mirë. Kur të trashëgohet një klasë si publike, të
gjithë anëtarët do të ruajnë specifikimet origjinale të qasjes.
Trashëgimia publike

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
129
Specifikuesi i
qasjes (bazë)
Specifikuesi i
qasjes (derivuar)
Qasja e klasës
së derivuar
Qasja jashtë
klasës
Public
Public
Po
Po
Protected
Protected
Po
Jo
Private
Private
Jo
Jo
Me trashëgimi private të gjithë anëtarë e klasës bazë janë të trashëguar si
private. Kjo do të thotë anëtarët private qëndrojnë private, dhe anëtarët e
mbrojtura dhe publik bëhen private.
Trashëgimia private
Specifikuesi i
qasjes (bazë)
Specifikuesi i
qasjes (derivuar)
Qasja e klasës
së derivuar
Qasja jashtë
klasës
Public
Public
Po
Jo
Protected
Protected
Po
Jo
Private
Private
Jo
Jo
Me trashëgimi të mbrojtur, anëtarët publik bëhet protected, kurse anëtarët
privat mbesin privat. Trashëgimia protected është e ngjashme sikurse edhe
trashëgimia private. Kjo mund të shihet edhe nga tabelat.
Trashëgimia e mbrojtur
Specifikuesi i
qasjes (bazë)
Specifikuesi i
qasjes (derivuar)
Qasja e klasës
së derivuar
Qasja jashtë
klasës
Public
Public
Po
Jo
Protected
Protected
Po
Jo
Private
Private
Jo
Jo
114. Të shkruhet programi, përmes të cilit krijohet klasa Baza në anëtarët e
së cilës paraqitet tri variabla, një publike, një private dhe një
protected. Të krijohet klasa derivuar dhe të trashëgohet si public nga
klasa bazë. Më pas të provohet me iu qasur anëtarëve të klasës së
derivuar.
#include <iostream>
using namespace std;
class Baza
{
public:
int a_publik;
private:
int a_privat;
protected:
int a_mbrojtur;
};
class derivuar: public Baza
{
derivuar()
{
// Klasa e derivuar gjithmonë përdorë specifikuesit e klasës prind
a_publik = 1;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
130
a_privat = 2; // Klasa e derivuar nuk mund të qaset tek anëtaret privat.
a_mbrojtur = 3;
}
};
int main()
{
derivuar obj;
obj.a_publik = 1;
obj.a_privat = 2; // është privat dhe nuk mundemi me iu qasur jashtë klasës
obj.a_mbrojtur = 3;
}
115. Të shkruhet programi, përmes të cilit krijohet klasa Baza në anëtarët e
së cilës paraqitet tri variabla, një publike, një private dhe një
protected. Të krijohet klasa derivuar dhe të trashëgohet si private nga
klasa bazë. Më pas të provohet me iu qasur anëtarëve të ndryshëm të klasës
bazë dhe të klasës së derivuar.
#include <iostream>
using namespace std;
class Baza
{
public:
int a_publik;
private:
int a_privat;
protected:
int a_mbrojtur;
};
class derivuar: private Baza
{
derivuar()
{
// Klasa e derivuar gjithmonë përdorë specifikuesit e klases prind
a_publik = 1;
a_privat = 2; // Klasa e derivuar nuk mund të qaset tek anetarët privat.
a_mbrojtur = 3;
}
};
int main()
{
derivuar obj;
// a_publik tashme është privat dhe nuk mundemi me iu qasur jashtë klasës
obj.a_publik = 1;
// a_privat tashme është privat dhe nuk mundemi me iu qasur jashtë klasës
obj.a_privat = 2;
// a_mbrojtur tashmë është privat dhe nuk mundemi me iu qasur jashte klasës
obj.a_mbrojtur = 3;
Baza obj_b;
obj_b.a_publik = 1;
// a_privat është privat dhe nuk mundemi me iu qasur jashtë klasës
obj_b.a_privat = 2;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
131
// a_mbrojtur është protected dhe nuk mundemi me iu qasur jashtë klasës
obj_b.a_mbrojtur = 3;
}
5.18. Operatori i shoqërimit tek objektet
Nëse janë deklaruar dy objekte të klasës, o1 dhe o2, përmes
operacionit të shoqërimit:
Vlerat e anëtarëve të objektit o1 do u shoqërohen anëtarëve të
objektit o2.
116. Të shkruhet programi dhe të krijohet klasa produkti e cila ruan peshën
dhe çmimin e produktit. Të deklarohet objekti i klasës dhe të iniciohet me
vlera. Këto vlera të vendosen në objektin e ri. Në fund të printohen
vlerat e anëtarëve për të dy objektet.
#include <iostream>
using namespace std;
class produkti
{
float pesha, cmimi;
public:
void v_vlerat(float p, float c)
{
pesha = p;
cmimi = c;
};
void shtypja()
{
cout << "\npesha = "
<< pesha
<< "\nmimi = "
<< cmimi
<< "\n\n";
}
};
int main()
{
produkti ob1, ob2;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
132
ob1.v_vlerat(1,2.55);
cout << "\nVlerat origjinale";
ob1.shtypja();
ob2=ob1; //shoqerimi i vlerave të ob1 tek ob2
cout << "Vlerat e shoqëruara";
ob2.shtypja();
system ("pause");
return 0;
}
5.19. Krahasimi i objekteve të klasës
Objektet e klasës nuk mund të krahasohen direkt mes vete. Nëse ob1 dhe ob2
janë objekte të klasës, atëherë nuk mund të kryhet krahasimi direkt.
Duke shfrytëzuar objektet mund të krahasohen vlerat e anëtarëve të klasës.
Nëse anetar1 dhe anetar2 janë anëtarë të klasës, kurse ob1 dhe ob2 janë dy
objekte të klasës, shihet se mund vlerat e anëtarëve mund të krahasohen.
117. Të shkruhet programi dhe të krijohet klasa produkti e cila ruan peshën
dhe çmimin e produktit. Të deklarohet dy objekte të klasës dhe të
iniciohen me vlera. Përmes funksionit shtypja të shtypen vlerat e
anëtarëve për të dy objektet. Më pas të krahasohen vlerat e tyre dhe të
tregohet nëse vlerat janë të barabarta ose jo.
#include <iostream>
using namespace std;
class produkti
{
public:
float pesha, cmimi;
void v_vlerat(float p, float c)
{
pesha = p;
cmimi = c;
};
void shtypja()
{
cout << "\nPesha = "
<< pesha
<< "\nÇmimi = "

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
133
<< cmimi
<< "\n\n";
}
};
int main()
{
produkti ob1, ob2;
ob1.v_vlerat(1,2.55);
ob2.v_vlerat(2.3,1.66);
cout << "\nVlerat në objektin ob1";
ob1.shtypja();
cout << "Vlerat në objektin ob2";
ob2.shtypja();
if ((ob1.pesha==ob2.pesha) && (ob1.cmimi==ob2.cmimi))
cout << "Vlerat jane te barabarta";
else
cout << "Vlerat nuk janë të barabarta\n\n" ;
system ("pause");
return 0;
}
5.20. Fushat brenda klasave
Në anëtarët e klasave mund të përfshihen edhe fusha (p.sh., vektorët,
matricat…). Rezervimi i vendeve të nevojshme për fushat bëhet përmes
deklarimit të një konstanteje para krijimit të klasave.
118. Të shkruhet programi dhe të krijohet klasa studenti e cila ka dy
anëtarë, një vektor për ruajtjen e notave dhe një funksion për llogaritjen
e notës mesatare.
#include <iostream>
#include <iomanip>
using namespace std;
const int m=10;
class studenti
{
public:
//int n; //nëse deklarohet n, anetari i parë i vektorit i shoqërohet n-it
float notat[m];
double mesatare()
{
double mes=0;
for (int i=0;i<m;i++)
mes=mes+notat[i];
return mes/m;
}
};
int main()

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
134
{
int i;
studenti st1 = {8,6,9,10,7,8,10,8,9,9};
cout << "\nNotat e studentit"
<< "\n-------------------\n";
for (i=0;i<m;i++)
cout<< setw(4)
<< i+1
<< setw(10)
<< st1.notat[i]
<< "\n";
cout << "-------------------\n"
<< "Nota mesatare: "
<< st1.mesatare()
<< "\n\n";
system("pause");
return 0;
}
5.21. Krijimi i fushave duke përdor objektet
Grupet e të dhënave të një klase të caktuar mund të vendosen në një
fushë të objektit përkatës. Gjatë kësaj, në një element të fushës
përfshihen të dhëna të cilat u përgjigjen anëtarëve të klasës në
fjalë.
119. Të shkruhet programi dhe të krijohet klasa personi e cila ka tre
anëtarë (emri, mbiemri dhe qyteti) të tipit char. Në funksionin main të
deklarohet një objekt vektor i klasës personi. Të ruhen të dhënat për 2
studentë dhe më pas të shtypen ato të dhëna.
#include <iostream>
#include <iomanip>
using namespace std;
class personi
{
public:
char emri[15];
char mbiemri[20];
char qyteti[20];
};
int main()
{
const int n=2;
personi studenti[n];
cout << "\nTë dhënat nga tastiera\n\n";
for (int i=0;i<n;i++)
{
cout << "Emri .......: ";
cin >> studenti[i].emri;
cout << "Mbiemri ....: ";
cin >> studenti[i].mbiemri;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
135
cout << "Qyteti .....: ";
cin >> studenti[i].qyteti;
cout << "\n";
}
cout << "\nTe dhënat e lexuara\n";
for (int i=0;i<n;i++)
{
cout << "\nEmri .......: "
<< studenti[i].emri
<< "\nMbiemri ....: "
<< studenti[i].mbiemri
<< "\nQyteti .....: "
<< studenti[i].qyteti
<< "\n";
}
cout << "\n";
system("pause");
return 0;
}
120. Të shkruhet programi dhe të krijohet klasa rezervimi dhe enumeration
ditet (hene, marte, merkure, enjte, premte, shtune, diele) si dhe një
vektor ditetJaves i tipit string për mbajtjen e ditëve të javës. Shënimet
e një klienti të lexohen përmes tastiere dhe dita e rezervimit të caktohet
duke përdorur grupin/enumaration. Përmes anëtarit të grupit të merret
vlera nga vektori ditetJaves në mënyrë që mesazhi të jetë sa më i
kuptueshëm për njeriun.
#include <iostream>
#include <string>
using namespace std;
string diteJaves[]={"E hene","E marte","E merkure","E enjte","e premte", "E shtune",
"E diele"};
enum ditet
{
hene,marte,merkure,enjte,premte, shtune, diele
};
class rezervimi
{
public:
int numri;
char emri[20];
int dita;
ditet vendosDiten()
{
ditet rez;
switch(dita)
{
case 1 :
rez=ditet::hene;
break;
case 2 :
rez=ditet::marte;
break;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
136
case 3 :
rez=ditet::merkure;
break;
case 4 :
rez=ditet::enjte;
break;
case 5 :
rez=ditet::premte;
break;
case 6 :
rez=ditet::shtune;
break;
case 7 :
rez=ditet::diele;
break;
default :
rez=ditet::diele;
break;
}
return rez;
}
};
int main()
{
rezervimi klienti;
cout<<"Numri i klientit: ";
cin>>klienti.numri;
cin.ignore();
cout<<"Emri i klientit: ";
cin.getline(klienti.emri,20);
cout<<"Dita (1=H, 2=M, 3=M, 4=E, 5=P, 6=S, 7=D: ";
cin>>klienti.dita;
cout<<"Të dhënat e klientit:\n"
<<"Numri i klientit:"<<klienti.numri<<endl
<<"Emri: "<<klienti.emri<<endl
<<"ka bërë rezervim për ditën " <<diteJaves[klienti.vendosDiten()]
<<endl;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
137
6. Pointerët
Pointeri është tip i të dhënave i përcaktuar nga përdoruesi i cili krijon
lloje të veçanta të variablave. Secili lokacion i memories i cili përdoret
për të ruajtur vlera të të dhënave e ka një adresë. Pra, pointeri është një
variabël që mban adresën e një variable tjetër. Pointeri mund të mbajë
adresën e të dhënave primitive si char, int, float, double ose të dhënave të
përcaktuara nga përdoruesi, si funksione, pointer ose të dhëna të derivuara
si fusha, struktura, grupe etj.
6.1. Deklarimi i pointerëve
Pointerët, si edhe variablat e tipave të tjerë, para se të shfrytëzohen duhet
të deklarohen. Deklarimi i pointerëve është pothuajse i njëjtë sikurse i
variablave të zakonshme. Për t'i dalluar pointerët nga variablat e zakonshme,
para pointerëve shënohet simboli *:
Tipi t i variablës p duhet të përputhet me tipin e variablës adresa e së
cilës do të ruhet në të.
121. Të deklarohen disa variante të variabla të tipit pointer.
#include <iostream>
using namespace std;
int main()
{
/*simboli * mund të shkruhet kudo
në mes tipit dhe emrit të pointerit*/
int *a;
int * b, *b1;
int* c;
float *d;
float * e;
double* f;
char *g;
int x, y, *h, *k;
long* pointer, number=99;
//lejohet inicimi vetem me zero dhe NULL
int *y=0;
int *z=NULL;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
138
6.2. Adresat e pointerëve
Duke e shfrytëzuar operatorin &, përmes shprehjes së formës:
adresa e variablës së zakonshme v vendoset të variabla p e cila është
variabël e tipit pointer.
122. Të shkruhet programi në të cilin deklarohet një variabël v dhe një
pointer. Më pas të merret dhe të shtypet adresa e variablës v duke e
shfrytëzuar pointerin p.
#include <iostream>
using namespace std;
int main()
{
int v=5;
int *p;
cout << "\nVlera e variablës v= "<< v
<< "\nAdresa e variablës v ="<<&v;
p=&v; //krijon një referencë tek v
cout << "\nAdresa e variablës v "
<<"përmes pointerit p: "
<< p
<< "\n\n";
system("pause");
return 0;
}
123. Të shkruhet programi në të cilin deklarohet variabla x e tipit int dhe
iniciohet me vlerën 37. Adresa e variablës x të ruhet në pointerin p.
Vlera e ruajtur në pointer të ndryshohet në 58. Më pas të shtypen adresat
e variablës x dhe adresa e pointerit si dhe vlera që është ruajtur në këtë
adresë.
#include <iostream>
using namespace std;
int main()
{

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
139
int *p;
int x = 37;
cout << "Vlera e variablës \t\tx = " << x << endl;
p = &x; // ruaj adresën e x ne p
cout<< "Vlera përmes pointerit \t\t*p = " << *p;
*p = 58; //ruaj vlerën 58 në adresën e pointerit
cout<< "\nVlera ne: \t\t\t*p = " << *p
<< "\nAdresa e pointerit \t\tp: " << &p
<< "\nAdresa e variablës \t\tx: " << p
<< "\nVlera ne adr. e pointerit \t = "<< *p
<< "\nAdresa e \t\t\tx: " << &x
<< "\nVlera e variablës \t\tx = " << x << endl;
system("pause");
return 0;
}
6.3. Përdorimi i vlerës së pointerit
Nëse dihet adresa e një variable, përmes procesit të deadresimit ose
dereferimit mund të vendoset ose të merret vlera e variablës. Për këtë qëllim
shfrytëzohet operatori *.
Vlera a variablës, adresa e së cilës është tek pointeri p do të ruhet në
variablën v. Operatorët & dhe * mes vete llogariten si operatorë inverzë.
124. Të shkruhet programi përmes së cilit tregohet shtypja e vlerës së
variablës a dhe variablës b. Vlera e variablës b të shtypet duke
shfrytëzuar adresën e cila ruhet tek pointeri p.
#include <iostream>
using namespace std;
int main()
{
int *p;
int a=200,b;
cout << "\nVlera e variablës a: "
<< a << "\n";
//adresa e variablës a ruhet tek pointeri p
p=&a;
cout<< "\nAdresa të variabla a: "
<< p << "\n";
/*vlera e variablës, adresa e së cilës
ruhet të pointeri p është ruajur tek

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
140
variabla b.*/
b=*p;
cout << "\nVlera e variablës b: "
<< b << "\n\n";
system("pause");
return 0;
}
6.4. Shoqërimi i vlerave
Variablave të tipave të zakonshëm, me ndërmjetësimin e pointerëve mund të u
shoqërohen vlera konstante ose vlera të variablave të tjera. Variablës,
adresa e së cilës ruhet të pointeri p, mund t'i shoqërohet një vlerë
konstante k.
Variablës, adresa e së cilës ruhet të pointeri p, mund t'i shoqërohet vlera e
një variable tjetër.
125. Të shkruhet programi përmes së cilit tregohet ndryshimi i vlerës së
variablës x në mënyrë indirekte duke e shfrytëzuar adresën e pointerit p1.
#include <iostream>
using namespace std;
int main()
{
int x = 2013;
int *p1 = &x;
cout<<"&x = "<< &x << "\t\tx = "<< x
<<"\np1 = "<< p1 << "\t\t*p1 = "<< *p1;
*p1 += 25; //rritet vlera e variablës
cout << "\n&x = " << &x << "\t\tx = " << x
<< "\np1 = " << p1 << "\t\t*p1 = " << *p1
<< "\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
141
126. Të shkruhet programi përmes së cilit tregohet vendosja e vlerës së
variablës x tek variabla y në mënyrë indirekte duke e shfrytëzuar adresën
e pointerit p.
#include <iostream>
using namespace std;
int main()
{
int x=1999,y;
int *p;
cout<< "\nVlera e variablës x = "
<< x;
/*Adresa e variables y është ruajtur
tek pointeri p.*/
p=&y;
cout << "\nAdresa e variablës x = "
<<&x
<<"\nAdresa e variablës y = "
<< p;
/*Vlera e x është ruajtur ne adresen
qe e cila është ruajtur tek pointeri p*/
*p=x;
cout << "\nVlera e variablës y = "
<< y << "\n\n";
system("pause");
return 0;
}
6.5. Llogaritjet përmes pointerëve
Për llogaritje të ndryshme përveç variablave, mund të shfrytëzohen edhe
pointerët.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
142
127. Të modifikohet programi i mëposhtëm dhe mbledhja ose zbritja të kryhet
duke shfrytëzuar pointerët.
#include <iostream>
using namespace std;
int main()
{
int x,y,z,*a,*b;
cout << "\nx = ";
cin >> x;
cout << "\ny = ";
cin >> y;
a=&x;
b=&y;
if (x>y)
{
z=*a+*b;
}
else
{
z=*a-*b;
}
cout << "\nz = "
<< z
<< "\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
143
6.6. Operimi me pointerë
Vlerat e pointerëve mund të rriten, të zvogëlohen, të krahasohen, ose përmes
operatorit të barazimit, ato vlera edhe mund t'u shoqërohen pointerëve të
tjerë. Operacione të vlefshme me pointerë janë:
 Mbledhja dhe zbritja e pointerit me një integer.
 Shoqërimi i pointerit të tipit të njëjtë.
 Zbritja ose krahasimi i dy pointerëve në fushën e njëjtë.
 Caktimi ose krahasimi me zero.
Nëse p1 dhe p2 janë variabla pointer, atëherë
e ndryshon vlerën e p1 dhe ajo tani është adresë e memories (pointer) në p2.
128. Të shkruhet programi duke shfrytëzuar një unazë nga 1 deri në 10.
Brenda unazës të rritet vlera e pointerit për 1 dhe të shtypet adresa e
pointerit.
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
int i,x;
int *p;
p=&x;
cout << "\n i adresa (hex) adresa(dec)"
<< "\n-------------------------------\n";
for (int i=1;i<=10;i++)
{
cout << setw(2)
<< i
<< setw(10)
<< p
<< setw(15)
<< (long)p //adresa në decimal
<< "\n";

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
144
p++;
}
cout << "-------------------------------\n";
system("pause");
return 0;
}
129. Të shkruhet programi në të cilin janë të deklaruar tri variabla: x, y
dhe z të cilat janë të iniciuara me vlera 25, 50 respektivisht 75. Duke
shfrytëzuar pointerin p, vlera e x të shumëzohet me 2, vlerës së y të i
zbriten 10 dhe vlerës së z të i shtohen 25.
#include <iostream>
using namespace std;
#include <iostream>
int main()
{
int x = 25, y = 50, z = 75;
int *p;
cout<< "Vlerat e x, y dhe z\n"
<<"x = " << x
<< "\ny = " << y
<< "\nz = " << z << endl;
p = &x; // ruaj adresën e x-it në p
*p *= 2; // shumëzo vlerën në x me 2
p = &y; // ruaj adresën e y-it në p
*p -= 10; // zbrit vlerën e y-it për 10
p = &z; // ruaj adresën e z-it në p
*p += 25; // shto vlerën ne z-it me 25
cout << "Vlerat e reja pr x, y dhe z jan\n"
<<"x = " << x
<< "\ny = " << y
<< "\nz = " << z << endl;
system("pause");
return 0;
}
130. Të shkruhet programi në të cilin janë të deklaruara dy variabla x dhe y
si dhe dy pointer xp dhe yp. Të bëhet krahasimi i vlerave të ruajtura në
pointer dhe të tregohet se vlera e cilës variabël është më e madhe.
#include <iostream>
using namespace std;
int main()
{
int x, y, *xp, *yp;
cout << " \nVlera x = ";
cin >> x ;
cout << " \nVlera y = ";
cin >> y ;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
145
xp = &x;
yp = &y;
if (*xp > *yp )
{
cout << " \nx është më i madh se y\n";
}
else
{
cout << "\ny është më i madh se x\n";
}
system("pause");
return 0;
}
131. Të shkruhet programi në të cilin deklarohet variabla x e tipit double
dhe dy pointer p1 dhe p2. Adresa e variablës x të i shoqërohet pointerit
p1 dhe p1 të barazohen me p2. Më pas të krahasohen nëse adresa të pointeri
p1 dhe p2 janë të barabarta.
#include <iostream>
#include <iostream>
using namespace std;
int main()
{
double x;
double *p1,*p2;
p1=&x;
cout << "\nAdresa të pointeri p1: "
<< p1;
p2=p1;
cout << "\nAdresa të pointeri p2: "
<< p2;
if (p1==p2)
cout << "\n\nPointerët janë të barabartë";
else
cout << "\n\nPointerët nuk janë të barabartë";
cout << "\n\n";
system("pause");
return 0;
}
132. Të shkruhet programi në të cilin deklarohet variabla a dhe pointeri ap.
Të tregohet se & dhe * janë inverz ndaj njëri tjetrit.
#include <iostream>
using namespace std;
int main()
{
int a;
int *ap;
a = 7;
ap = &a;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
146
cout << "Adresa e variablës a është " <<&a
<<"\nVlera te pointeri ap është " <<ap;
cout << "\n\nVlera e variablës a është " << a
<< "\nVlera te pointeri *ap është "<< *ap;
cout << "\n\nTregon se * dhe & janë inverz ne "
<< "njeri tjetrin.\n&*ap = "<<&*ap
<< "\n*&ap = " << *&ap<<endl;
system("pause");
}
6.7. Operatori new dhe delete
Derisa një pointer mund të përdoret për t'iu referuar një variable, programi
mund të manipulojë me variabla edhe nëse variablat nuk kanë identifikues për
emrin e tyre. Operatori new mund të përdoret për të krijuar variabla që nuk
kanë identifikues për emrat e tyre. Këto variabla pa emër janë të referuara
nëpërmjet pointerëve. Shembulli vijues krijon një variable të re të tipit int
dhe vendos variablën pointer p1 në adresën e kësaj variable.
p1=new int;
Një zonë e veçantë e memories e quajtur freestore ose heap është e rezervuar
për variablat dinamike. Secila variabël e re dinamike e krijuar prej
programit konsumon një pjesë të memories në freestore. Madhësia e freestore
ndryshon në varësi të implementimeve të C++.
Operatori delete e eliminon variablen dinamike e rikthen memorien që e ka
rezervuar variabla e krijuar në mënyrë dinamike. Memoria e liruar mund ë
përdoret përsëri nga variablat dinamike. Shprehja e mëposhtme
delete p;
e eliminon variablen dinamike, adresa e së cilës është pointuar tek pointeri
p.
133. Të shkruhet programi në të cilin deklarohet dy pointer p1 dhe p2. Duke
përdorur pointerin p1 dhe operatorin new të krijohen dy variabla dinamike
të tipit int dhe të iu shoqërohen vlera konstante. Në fund të lirohet
hapësira memoruese e cila është rezervuar me rastin e krijimit të krijimit
të variablave dinamike
#include <iostream>
using namespace std;
int main()
{
int *p1, *p2;
p1 = new int;//krijo një variabël të tipit int
*p1 = 44;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
147
p2 = p1;
cout << "*p1 == " << *p1 << endl;
cout << "*p2 == " << *p2 << endl;
*p2 = 55;
cout << "*p1 == " << *p1 << endl;
cout << "*p2 == " << *p2 << endl;
p1 = new int; //krijo një variabël të tipit int
*p1 = 88;
cout << "*p1 == " << *p1 << endl;
cout << "*p2 == " << *p2 << endl;
system("pause");
return 0;
}
134. Të shkruhet programi në të cilin deklarohet klasa personi e cila ruan
emrat e disa personave dhe ka funksionin për vendosjen dhe leximin e
emrave. Të deklarohet pointeri persPtr i klasës personi dhe duke
shfrytëzuar operatorin new të krijohen objekte të reja dhe të vendosen
disa emra. Më pas të shfrytëzohet pointeri dhe një unazë për të printuar
emrat dhe numrin rendor të anëtarëve.
#include <iostream>
using namespace std;
class personi
{
protected:
char emri[40];
public:
void vendos_emrin()
{
cout << "Emri: ";
cin >> emri;
}
void lexo_emrin()
{
cout << "\nEmri: " << emri;
}
};
int main()
{
personi* persPtr[50]; //vektor pointeri në klasën personi
int n = 0;
char pyetja;
do
{
persPtr[n] = new personi; //objekt i ri
persPtr[n]->vendos_emrin();
n++; //numero personat
cout << "Regjistro person tjet베(p/j)? ";
cin >> pyetja;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
148
}while( pyetja=='p' );
for(int j=0; j<n; j++)
{
cout << "\nNumri: " << j+1;
persPtr[j]->lexo_emrin();
}
cout << endl;
system("pause");
return 0;
}
6.8. Pointerët const
Ka dy vende kur fjala çelës const mund të vendoset brenda një deklarimi të
variablës pointer. Varianti i parë është kur fjala const pas shenjës *
(ylli).
int * const ptr;
deklaron një pointer konstant në të dhëna të ndryshueshme integer. Vlera
integer mund të ndryshohet përmes këtij pointeri, por pointeri nuk mund të
ndryshohet për të treguar vlera të ndryshme si konstante integer. Me fjalë të
tjera pointeri konstant është një tregues që nuk mund të ndryshojë adresën.
Varianti i dytë është kur fjala çelës const paraqitet para tipit të të
dhënave.
const int *ptr;
deklaron një pointer të ndryshueshëm në një konstante integer. Vlera integer
nuk mund të ndryshohet përmes këtij pointeri, por pointeri mund të ndryshohet
për të treguar adresa të ndryshme të konstanteve integer. Sikurse konstantet
normale edhe pointeri konstant duhet të iniciohet gjatë deklarimit.
135. Të shkruhet programi në të cilin deklarohet një pointer konstant tek i
cili mund të ndryshohet vlera por jo adresa. Vlera fillestare të
ndryshohet dhe me pas të shtypet vlera e variablës dhe adresa variablës
duke shfrytëzuar pointerin.
#include<iostream>
using namespace std;
int main()
{
int vlera = 5;
int *const vPtr = &vlera;
*vPtr = 10; //lejohet ndryshimi i adresës, por jo i vlerës
cout<< vlera <<" - " <<vPtr
<<"\n"
<<*vPtr <<" - " <<vPtr
<<"\n";

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
149
system("pause");
return 0;
}
136. Të shkruhet programi në të cilin deklarohet një pointer konstant tek i
cili mund të ndryshohet adresa, por jo vlera. Për këtë të deklarohen dy
variabla dhe pointerit të i ndryshohet adresa prej variablës së parë tek e
dyta. Më pas të shtypen vlerat e variablave dhe adresar e tyre duke
shfrytëzuar pointerin.
#include<iostream>
using namespace std;
int main()
{
int vlera1 = 10;
int vlera2 = 15;
const int * vPtr = &vlera1;
vPtr = &vlera2; // lejohet ndryshimi i adresës, por jo i vlerës
cout<< vlera1 <<" - " <<vPtr
<<"\n"
<<vlera2 <<" - " <<vPtr
<<"\n";
system("pause");
return 0;
}
6.9. Pointerët dhe fushat
Emri i një fushe është në fakt një pointer për elementin e parë në grup.
Deklarimi fusha[3] i tregon kompajlerit që të kthejë elementin që është 3
elemente larg nga elementi i fillimit. Kjo shpjegon pse fushat kanë qenë
gjithmonë si referencë: pasimi i një fushe me të vërtetë është pasimi i një
pointeri. Kjo gjithashtu shpjegon pse indekset e fushave fillojë në 0:
elementi i parë i një fushe është element që është 0 elemente larg nga
fillimi i fushës. Mund të thuhet se fushat janë të lidhura ngushtë me
pointerët dhe janë sinonim në aspektin se si i qasen memories. Për të iu
qasur anëtarit të i-të vektorit v me ndërmjetësimin e pointerit p mund të
shfrytëzohet shprehja:
p = &v[i];
Në fusha, emri i fushës tregon gjithmonë për elementin e parë. Adresa e
anëtarit të parë të fushës është &v[0].
Nëse janë të deklaruara: int a[m]; dhe int* p; atëherë p=a dhe a=p janë të
vlefshme dhe

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
150
Dallimi i vetëm në mes tyre është se vlera e "p" mund të ndryshojë tek secila
adresë e variablës integer, ndërsa "a" gjithmonë do të tregojë një fushë
integer me madhësi m.
137. Të shkruhet programi përmes së cilit tregohet shfrytëzimi i pointerit p
për shtypjen e adresave të vektorit v(5).
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
int v[5], *p;
for(int i=0;i<5;++i)
{
p=&v[i];
cout<<"Adresa e v["<<i<<"]="
<<p<<"\n";
}
system("pause");
return 0;
}
138. Të shkruhet programi përmes së cilit shtypen anëtarët e vektorit vek[]
në menyrë direkte dhe përmes pointerit pvek duke pasur parasysh që vlejnë
shprehjet a[i]  *(a+i) dhe p[i]  *(p+i).
#include <iostream>
using namespace std;
int main()
{
int vek[] = { 10, 20, 30, 40 };
int *pvek = vek;
cout << "Printimi përmes emrit të vektorit\n";
for ( int i = 0; i < 4; ++i )
cout << "vek[" << i << "] = " <<vek[i] << '\n';
cout << "\nPrintimi përmes emrit të vektorit dhe operatorit *\n";
for ( int j = 0; j < 4; ++j )
cout << "*(vek + " << j << ") = " <<*(vek + j ) << '\n';

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
151
cout << "\nAnëtaret përmes pointerit \n";
for ( int k = 0; k < 4; ++k )
cout << "pvek[" << k << "] = " << pvek[k] << '\n';
cout << "\nAnëtaret përmes pointerit me zhvendosje\n";
for ( int m = 0; m < 4; ++m )
cout << "*(pvek + " << m << ") = "
<< *( pvek + m ) << '\n';
system("pause");
return 0;
}
139. Të shkruhet programi përmes së cilit tregohet mbushja e anëtarëve të
vektorit arr[m] duke shfrytëzuar pointerin p.
#include <iostream>
using namespace std;
int main()
{
const int m=5;
int i, *p, arr[m];
//mbushja e anetareve te vektorit
for (i = 0; i < m; i++)
{
arr[i] = m;
}
//ndryshimi i vlerave permes pointerit
for (p = arr; p < &arr[m]; p++)
{
*p = m+1;
}
//shtypja e vlerave te anetareve te vektorit
for (i = 0; i < m; i++)
{
cout<< arr[i] ;
if (i<m-1)
cout <<", ";
}
cout<<endl;
system("pause");
return 0;
}
140. Të shkruhet programi përmes së cilit shtypen anëtarët e matricës
A[m][m] përmes pointerit pA sikurse shihet në pamjen e mëposhtme.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
152
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
const int m=4;
int A[m][m]={
{1,2,3,-1},
{2,3,-1,4},
{3,-1,4,5},
{-1,1,2,3},
};
int i,j,k=0,*pA;
char vija[]="--------------------------\n";
cout << "\nVl. Adr(Hex) Adr(Dec)\n"
<<vija;
pA=&A[0][0];
for (i=0;i<m;i++)
{
for (j=0;j<m;j++)
{
cout << setw(2)
<<*(pA+k)
<<setw(10)
<< pA
<<setw(10)
<< (long)pA;
pA=pA+1;
cout<<endl;
}
cout << endl;
}
cout << vija;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
153
6.10. Ponterët stringje
Një pointer karakter është një tregues/pointer për adresën e një variable të
tipit karakter, p.sh char *p;
Pointeri k tregon për sekuencën e karaktereve dhe mund të lexohet sikurse të
ishte një vektor.
141. Të shkruhet programi në të cilin deklarohet një pointer k i tipit char
dhe të shtypet vlera e tij.
#include<iostream>
using namespace std;
int main()
{
char *k = "tung";
cout<<"\nk =["<<k <<"]"
<<"\n";
system("pause");
return 0;
}
6.11. Fusha pointerësh
Për të vendosur stringje brenda fushave, p.sh., siç janë emrat e ndryshëm,
fushat duhet të deklarohen si dy dimensionale, përkatësisht si matrica.
Por, nëse fushat e tilla ruhen në një vektor të deklaruar si fushë pointerësh
(ang. array of pointers), hapësira memoruese do të jetë minimale.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
154
Nëse është deklaruar një matricë e tipit char e cila ruan ditët e javës dhe
të njëjtat vlera ruhen edhe përmes pointerit.
Atëherë më poshtë shihet se si rezervohet memoria kur ditët e javës janë
ruajtur në matricë dhe si kur janë të ruajtura në pointer.
Pamja në të majtë paraqet se si është rezervuar memoria kur ditët e javës
janë ruajtur në matricë dhe shihet se dita e mërkure është dita më e gjatë
dhe edhe për ditët më të shkurta është dashur të rezervohet memorie e njëjtë
si për ditën e mërkure. Si pasojë një pjesë e memories është rezervuar, por
nuk është shfrytëzuar (ka shkuar dëm). Kurse me rastin kur ditët janë ruajtur
përmes pointerit shihet se memoria është menaxhuar më mirë dhe dita vijuese
ka vazhduar pas ditës paraardhëse dhe pointeri e ruan vetëm adresën e
shkronjës së parë.
#include <iostream>
using namespace std;
const int m = 4;
int main)
{
char *studentet[m] ={
"Filan Fisteku",
"Kosovare Shkodra",
"Saranda Prizreni",
"Milot Mitrovica",

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
155
};
for (int i = 0; i < m; i++)
{
cout<< "Studenti[" << i << "] = "
<< studentet[i] << endl;
}
system("pause");
return 0;
}
6.12. Pointerët si parametra të funksioneve
Pointerët mund të jenë si parametra të funksioneve, mund të kthehen nga
funksionet, mund të ruhen në fusha, dhe mund të shoqërohen në pointerë të
funksioneve tjera
142. Të shkruhet programi përmes së cilit bëhet konvertimi prej inçëve në
centimetra. Për këtë të shfrytëzohet funksioni inchNeCm i cili ka
parametrin formal p të tipit pointer.
#include <iostream>
using namespace std;
double inchNeCm(double*); //prototipi
int main()
{
double y,x = 5.0;
cout << "x = " << x << " inch"
<< endl;
y=inchNeCm(&x); //dergo adresen e var
cout << "y = " << y << " centimetra"
<< endl;
system("pause");
return 0;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
156
}
double inchNeCm(double* p)
{
double y;
y =*p * 2.54;
return y;
}
143. Të shkruhet programi përmes së cilit llogaritet vlera e shprehjes së
mëposhtme duke shfrytëzuar funksionin shuma. Funksioni shuma si parametra
formalë të tipit pointerë ka x, n dhe y. Funksioni rezultatin ta ruajë
hapësirën memoruese, adresa e së cilës ruhet në pointerin y.
#include <iostream>
using namespace std;
void shuma(double *x, int *n, double *y);
int main()
{
int n;
double x,y;
cout << "Vlera x = ";
cin >> x;
cout << "Vlera n = ";
cin >> n;
shuma(&x,&n,&y);
cout << "\nVlera y = "
<< y
<< "\n\n";
system("pause");
return 0;
}
void shuma(double *x, int *n, double *y)
{
double s=0;
for (int i=3;i<=*n;i++)
s=s+(3*i-2*(*x));
*y=pow((*x+3),2) + s;
return;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
157
6.13. Pointerët në funksione
Funksionet gjatë ekzekutimit të programit vendosën në hapësira të caktuara
memoruese. Adresa ku fillon vendosja e një funksioni në memorien e
kompjuterit quhet adresë e funksionit. Për ruajtjen e adresës së funksionit
shfrytëzohet pointeri në funksion, i cili njihet edhe si pointer funksioni.
Pointeri i funksionit mund të shfrytëzohet për thirrjen e funksionit adresa e
së cilit është ruajtur tek ky pointer.
Në skemën e sipërme shihet se si është deklaruar pointeri për funksionin
shuma. Funksioni shuma ka dy parametra formalë të tipit integer dhe prandaj
edhe pointeri duhet të ketë parametrat e njëjtë sikurse funksioni.
144. Të shkruhet programi përmes së cilit llogaritet vlera e shprehjes së
mëposhtme duke shfrytëzuar funksionin shuma. Funksioni shuma të thirret
përmes pointerit p.
#include <iostream>
using namespace std;
void shuma(int n);
int main()
{
void (*p)(int);
p=shuma;
int n=10;
(*p)(n);
system("pause");
return 0;
}
void shuma(int n)
{
int y=0;
for (int i=1; i<=n;i++)
y=y+i;
cout << "\ny="
<< y
<< "\n\n";
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
158
145. Të shkruhet programi i cili përmes funksionit shkembe_vlerat i
shkëmben vlerat e parametrave të funksionit. Parametrat e funksionit janë
pointer.
#include <iostream>
using namespace std;
void shkembe_vlerat(int *px, int *py)
{
int temp;
temp = *px;
*px = *py;
*py = temp;
}
int main()
{
int a = 10, b = 20;
cout<< "a = "<< a
<< "\nb = " <<b;
shkembe_vlerat(&a, &b);
cout<<"\n-----------------\n"
<< "\na = "<< a
<< "\nb = " <<b
<<"\n\n";
system("pause");
return 0;
}
146. Të shkruhet programi në të cilin krijohet funksioni mesatarja për
gjetjen e notës mesatare. Në funksionin main të deklarohet një vektor me
madhësi m dhe i iniciuar me nota. Ky vektor të jetë parametri i parë,
kurse madhësia e vektorit të jetë parametri i dytë gjatë thirrjes së
funksionit mesatarja.
#include <iostream>
using namespace std;
double mesatarja(int *, int );
const int m=5
int main()
{
int notat[m] = {6, 8, 10, 9, 9};
double mes;
mes = mesatarja(notat, 5) ;
cout << "Nota mesatare = " << mes << endl;
system("pause");
return 0;
}
double mesatarja(int *vek, int m)
{

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
159
double s=0;
for (int i = 0; i < m; ++i)
{
s += vek[i];
}
return double(s) / m;
}
147. Të shkruhet programi përmes së cilit llogaritet faktorieli n! duke
shfrytëzuar funksionin faktorieli. Funksioni faktorieli të thirret përmes
pointerit p.
#include <iostream>
using namespace std;
void faktorieli(int);
int main()
{
void (*p)(int);
p=faktorieli;
int n=6;
(*p)(n);
system("pause");
return 0;
}
void faktorieli(int n)
{
long f=1;
for (int i=1; i<=n;i++)
f=f*i;
cout << "\nf="
<< f
<< "\n\n";
}
6.14. Pointerët në struktura
Pointerët, përveç tek të dhënat e tipave të zakonshëm, mund të shfrytëzohen
edhe gjatë operimit me struktura. Deklarimi i variablave të tipit pointer për
strukturat dhe operimin me anëtarët e tyre nuk dallon nga mënyra e
shfrytëzimit të pointerëve për tipat e zakonshëm të të dhënave. Më poshtë
është dhënë një shembull i deklarimit të një strukture dhe deklarimi i
pointerit të kësaj strukture.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
160
148. Të shkruhet programi në të cilin deklarohet struktura vija e cila ruan
koordinatat e pikës A dhe B. Në funksionin main të deklarohet një pointer
i strukturës dhe qasja tek anëtarët e strukturës të bëhet përmes
pointerit.
#include <iostream>
using namespace std;
struct vija
{
double x1,y1;
double x2, y2;
};
int main()
{
vija v;
vija *p;
p=&v;
(*p).x1=0;
(*p).y1=0;
(*p).x2=5;
(*p).y2=5;
cout<< "\n\nPika A = ("
<< (*p).x1
<<", "
<<(*p).y1
<<")";
cout << "\nPika B = ("
<< (*p).x2
<<", "
<<(*p).y2
<<")"
<< "\n\n";
system("pause");
return 0;
}
149. Të modifikohet shembulli paraprak dhe për të qasje tek anëtarët e
strukturës të përdoret operatori ->.
#include <iostream>
using namespace std;
struct vija

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
161
{
double x1,y1;
double x2, y2;
};
int main()
{
vija v;
vija *p;
p=&v;
p->x1=0;
p->y1=0;
p->x2=5;
p->y2=5;
cout<< "Pika A = ("
<< p->x1
<<", "
<<p->y1
<<")";
cout << "\nPika B = ("
<< p->x2
<<", "
<<p->y2
<<")"
<< "\n\n";
system("pause");
return 0;
}
6.15. Pointerët në objekte
Pointerët mund të shfrytëzohen gjatë operimit me objekte të klasave, njëlloj
sikurse edhe tek strukturat. Shembulli më poshtë paraqet se si është
deklaruar një objekti i klasës dhe si pointeri i klasës.
150. Të shkruhet programi, përmes së cilit krijohet klasa rrethi. Brenda
klasës të krijohet rrezja si private dhe funksionet publike vendos_rrezen
dhe siperfaqja. Objekti i klasës të jetë pointeri rrp.
#include <iostream>
using namespace std;
const double pi=3.1415;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
162
class rrethi
{
private:
double rrezja;
public:
void vendos_rrezen(double);
double siperfaqja();
};
void rrethi::vendos_rrezen(double r)
{
rrezja = r;
}
double rrethi::siperfaqja()
{
return pi * rrezja * rrezja ;
}
int main)
{
rrethi rr, *rrp;
rrp=&rr;
rrp->vendos_rrezen(5.6);
cout<<"Siperfaqja e rrethit = "
<<rrp->siperfaqja()
<< "\n\n";
system("pause");
return 0;
}
151. Të shkruhet programi në të cilin krijohet klasa Kutia me anëtarë privat
lartesia, gjeresia, lartesia, dhe anëtarë publik funksionin vellimi dhe
konstruktorin e klasës. Vlerat e nënkuptuara për anëtarët privat të jenë
1.0. Më pas të deklarohen dy objekte dhe të iniciohen me vlera duke
shfrytëzuar konstruktorin. Pointeri të shfrytëzohet për ruajtjen e
adresave të objektit të parë dhe të dytë dhe shtypjen e vëllimit për
secilin objekt.
#include <iostream>
using namespace std;
class Kutia
{
private:
double gjatesia;
double gjeresia;
double lartesia;
public:
Kutia(double gjat=1.0, double gjer=1.0, double lar=1.0)
{
cout <<"Konstruktori u thirr." << endl;
gjatesia = gjat;
gjeresia = gjer;
lartesia = lar;
}
double vellimi()

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
163
{
return gjatesia * gjeresia * lartesia;
}
};
int main()
{
Kutia kutia1(4.49, 3.27, 3.41);
Kutia kutia2(5.55, 2.22, 3.33);
Kutia *pKutia; // Deklarimi i pointerit të klases.
pKutia = &kutia1; // adresa e kutia1 ruhet tek pointeri
cout<< "V묬imi i kutis렱: "
<< pKutia->vellimi()
<< endl;
pKutia = &kutia2; // adresa e kutia2 ruhet tek pointeri
cout<< "Vëllimi i kutisë: "
<< pKutia->vellimi()
<< endl;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
164
7. Referencat
7.1. Referencat e zakonshme
Në C++, përmes referencave mund të deklarohen dy ose më shumë variabla ose
objekte, tek të cilat ruhen të dhëna të njëjta. Ndryshimi tek njëra do të
përcillet edhe tek tjetra. Referencat kryesisht shfrytëzohen gjatë operimit
me parametrat e funksioneve. Për deklarimin e referencave shfrytëzohet
operatori për referim &. Forma e përgjithshme e deklarimi të një reference
është dhënë më poshtë.
Ku t paraqet tipin e të dhënave për variablën referente; & -operatorin për
referim, r – variabla referente; v – variabla së cilës i referohet variabla
referente r.
Referenca është emri i një lokacioni. P.sh up është një variabël e tipit int
dhe fiek është një referencë e variablës up.
int up;
int& fiek = up;
152. Të shkruhet programi në të cilin deklarohet një variabël v e tipit
integer si dhe variabla referente vref. Vlera e variablës vref të rritet
për 1 dhe më pas të shtypet vlera e variablës v.
#include <iostream>
using namespace std;
int main()
{
int v=15;
int &vref = v;
v++;
cout<< "Vlera e vref është: "
<<vref
<<endl;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
165
7.2. Parametrat referentë
Referenca ofron një pseudonim të ndryshëm për një variabël. Përdorimi më i
rëndësishëm i referencave është tek funksionet, ku referencat pasohet si
parametra të funksioneve. Në rastin kur funksionit i pasohen parametrat sipas
vlerës, funksioni i thirrur krijon variabla të reja me tip të njëjtë dhe i
kopjon vlerat e parametrave duke i vendosur në këto variabla. Pra funksioni i
thirrur nuk ka qasje tek variabla e cila është e deklaruar tek funksioni
thirrës, por vetëm në kopjen e krijuar.
Për të deklaruar një parametër referent të funksionit, pas tipit të të
dhënave shënohet simboli & dhe me pas emri i parametrit. Parametri i tillë
paraqet një parametër formal referent. Emri parametrit në trupin e funksion
të thirrur i referohet variablës origjinale në funksionin thirrës. Parametrat
referentë janë të dobishëm për kthimin e vlerave/rezultateve të shumëfishta.
Më poshtë është deklaruar një funksion me emrin ndrysho i cili si parametër
formalë referentë e ka parametrin pref.
153. Të shkruhet programi në të cilin deklarohet funksioni param_ref i cili
ka një parametër formalë referentë dhe parametrin formal e rrit për një.
Nga funksioni kryesor të thirret funksioni param_ref për dy variabla të
deklaruara dhe të iniciuara brenda funksionit kryesor.
#include <iostream>
using namespace std;
void param_ref(int &pref)
{
pref++;
}
int main()
{
int a=10;
int b=20;
param_ref(a) ;
param_ref(b) ;
cout<< "a = " << a
<< " b = "<< b
<<endl;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
166
system("pause");
return 0;
}
154. Të shkruhet programi në të cilin deklarohet funksioni shkembe i cili
shkëmben vlerat e parametrave formalë referentë. Nga funksioni kryesor të
thirret funksioni shkembe për dy variabla të deklaruara dhe iniciuara
brenda funksionit kryesor.
#include <iostream>
using namespace std;
void shkembe(int& x, int& y)
{
int temp = x;
x = y;
y = temp;
}
int main()
{
int a=10;
int b=20;
shkembe(a,b) ;
cout<< "a = " << a
<< " b = "<< b
<<endl;
system("pause");
return 0;
}
155. Të shkruhet programi në të cilin deklarohet funksioni SinCos i cili
llogarit sinusin dhe kosinusin e këndit të dhënë. Sinusi dhe kosinusi të
jenë parametra referentë të funksionit SinCos. Nga funksioni kryesor të
thirret funksioni SinCos për këndin 45◦.
#include <iostream>
using namespace std;
const double pi=3.1415;
void SinCos(double kendi, double &Sin, double &Cos)
{
Sin = sin(kendi);
Cos = cos(kendi);
}
int main()
{
double Sin = 0.0;
double Cos = 0.0;
double kendi=45*(pi/180); //këndi 45 në radian
SinCos(kendi, Sin, Cos);

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
167
cout << "Sinusi " << Sin << endl;
cout << "Kosinusi " << Cos << endl;
system("pause");
return 0;
}
156. Të shkruhet programi në të cilin deklarohen dy funksione funk1 dhe
funk2. Funksioni parë e ka një parametër referentë, kurse funksioni i dytë
e ka një parametër konstant referent. Të thirren të dy funksionet për
vlera të njëjta dhe të vërehet dallimi në mes parametrit referentë dhe
parametrit konstant referent.
#include <iostream>
using namespace std;
int funk1(int& nr1);
int funk2(const int& nr2);
int main()
{
int numri1(4);
int vlera1(6);
char vija[]="\n------------------------------\n";
cout<<vija;
int rez1 = funk1(numri1);
cout<< "\nfunk1(numri1) = " << rez1
<< "\nnumri1 = " << numri1
<<endl;
rez1 = funk1(vlera1);
cout<< "\nfunk1(vlera1) = " << rez1
<< "\nvlera1 = " << vlera1
<< vija;
int numri2(4);
int vlera2(6);
cout<<vija;
int rez2= funk2(numri2);
cout << "\nfunk2(numri2) = " << rez2
<< "\nnumri2 = " << numri2
<<endl;
rez2 = funk2(vlera2);
cout << "\nfunk2(vlera1) = " << rez2
<< "\nvlera2 = " << vlera2
<< vija;
system("pause");
return 0;
}
int funk1(int& numri1) // Funksioni me parametër referent
{

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
168
cout << endl << "Vlera e pranuar = " << numri1;
numri1 += 10;
return numri1;
}
int funk2(const int& numri1) // Funksioni me parameter konstant referent
{
cout << endl << "Vlera e pranuar = " << numri1;
// numri1 += 10; // veprim jo i lejueshuem nga kompajleeri
return numri1+10;
}
7.3. Fushat referente
Gjatë operimit me anëtarët e fushave (vektorë, matrica...), si referente mund
të deklarohen edhe fushat. Vlerat e anëtarëve të fushës referente barazohen
me vlerat e anëtarëve të fushës për të cilën është krijuar referenca. Forma e
përgjithshme për të deklaruar një vektor apo matricë referente është dhënë më
poshtë.
Ku t – është tipi i të dhënave për vektorin/matricën referente; & - operatori
për referim; R – vektori/matrica referente; m – numri anëtarëve/rreshtave të
vektorit/matricës referente; n – numri i shtyllave të matricës referente; V –
vektori të cilit i referohet vektori referent; M – matrica të cilës i
referohet matrica referente.
157. Të shkruhet programi përmes të cilit tregohet deklarimi i vektorit B(m)
si vektor referent i vektorit A(m). Vektori A(m) gjatë deklarimit të
iniciohet me vlera.
#include<iostream>
#include <iomanip>
using namespace std;
int main()
{
const int m=5;
int A[m]={2,5,8,9,1};
int (&B)[m]=A; //vektori referent
cout << "Vektori origjinal A\n\n";
for (int i=0;i<m;i++)
cout << setw(3)
<< A[i];
cout << "\n\nVektori referent B\n\n";
for (int i=0;i<m;i++)
cout << setw(3)
<< B[i];
cout << "\n\n";

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
169
system("pause");
return 0;
}
158. Të shkruhet programi përmes të cilit tregohet deklarimi i matricës
B(m,n) si matricë referente e matricës A(m,n). Matrica A(m,n) të mbushet
me vlera të çfarëdoshme përmes një unaze.
#include<iostream>
#include <iomanip>
using namespace std;
int main()
{
const int m=5;
int A[m][m];
for (int i=0; i<m;i++)
for (int j=0;j<m;j++)
A[i][j]=i*j;
int (&B)[m][m]=A; //matrica referente
cout << "Matrica origjinale A\n\n";
for (int i=0;i<m;i++)
{
for (int j=0;j<m;j++)
cout << setw(5)
<< A[i][j];
cout << "\n";
}
cout << "\n\nMatrica referente B\n\n";
for (int i=0;i<m;i++)
{
for (int j=0;j<m;j++)
cout << setw(5)
<< B[i][j];
cout << "\n";
}
cout << "\n\n";
system("pause");
return 0;
}
7.4. Parametrat referentë brenda anëtarëve të
strukturave
Parametrat e funksioneve që shfrytëzohen brenda komponentëve të strukturave
mund të jenë edhe si parametra referentë. Kjo ka rëndësi të veçantë kur prej
strukturës dëshirohet të merren rezultatet e llogaritjeve të ndryshme dhe jo
vetëm një rezultat. Në shembullin më poshtë është dhënë struktura rrethi e

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
170
cila njërin nga anëtarët e saj e ka funksionin lexo i cili ka dy parametra
formalë referentë.
159. Të shkruhet programi në të cilin shfrytëzohet struktura rrethi me
variablat r, s, dhe p. Të llogaritet sipërfaqja dhe perimetri i rrethit
dhe rezultati të ruhet në variablat e strukturës s dhe p. Për të lexuar
vlerat e variablave s dhe p të shfrytëzohet funksioni lexo me parametrat
referentë x dhe y.
#include<iostream>
using namespace std;
const double pi=3.1415;
struct rrethi
{
double r,s,p;
void vendos_rrezen();
void llogarit();
void lexo(double &x,double &y);
};
void rrethi::vendos_rrezen()
{
cout << "\nRrezja r=";
cin >> r;
}
void rrethi::llogarit()
{
s=pi*r*r;
p=2*pi*r;
}
void rrethi::lexo(double &x,double &y)
{
x=s;
y=p;
}
int main()
{
rrethi rr;
double s,p;
rr.vendos_rrezen();
rr.llogarit();
rr.lexo(s,p);
cout<< "\nSipërfaqja s=" << s
<< "\nPerimetri p="<< p
<< "\n\n";
system("pause");

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
171
return 0;
}
160. Të shkruhet programi në të cilin shfrytëzohet struktura sfera me
variablat r, s, dhe v. Të llogaritet sipërfaqja dhe vëllimi i sferës dhe
rezultati të ruhet në variablat e strukturës s dhe v. Për të lexuar
vlerat e variablave s dhe v të shfrytëzohet funksioni lexo me parametrat
referentë x dhe y.
#include<iostream>
using namespace std;
const double pi=3.1415;
struct sfera
{
double r,s,p;
void vendos_rrezen();
void llogarit();
void lexo(double &x,double &y);
};
void sfera::vendos_rrezen()
{
cout << "\nRrezja r=";
cin >> r;
}
void sfera::llogarit()
{
s=4*pi*r*r;
p=(4/3)*pi*r*r*r;
}
void sfera::lexo(double &x,double &y)
{
x=s;
y=p;
}
int main()
{
sfera rr;
double s,p;
rr.vendos_rrezen();
rr.llogarit();
rr.lexo(s,p);
cout<< "\nSipërfaqja s=" << s
<< "\nVellimi v="<< p
<< "\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
172
7.5. Parametrat referentë brenda anëtarëve të
klasave
Ngjashëm sikurse strukturat, edhe tek klasat mund të shfrytëzohen parametra
referentë. Parametrat referentë janë si parametra të funksioneve brenda
anëtarëve të tyre.
161. Të shkruhet programi në të cilin shfrytëzohet klasa rrethi me anëtarët
privat r, s, dhe p. Të llogaritet sipërfaqja dhe perimetri i rrethit dhe
rezultati të ruhet në anëtarët privat të klasës, s dhe p. Për të lexuar
vlerat e variablave s dhe p të shfrytëzohet funksioni lexo me parametrat
referentë x dhe y.
#include<iostream>
using namespace std;
const double pi=3.1415;
class rrethi
{
private:
double r,s,p;
public:
void vendos_rrezen();
void llogarit();
void lexo(double &x,double &y);
};
void rrethi::lexo(double &x,double &y)
{
x=s;
y=p;
}
void rrethi::vendos_rrezen()
{
cout << "\nRrezja r=";
cin >> r;
}
void rrethi::llogarit()
{
s=pi*r*r;
p=2*pi*r;
}
int main()

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
173
{
rrethi rr;
double s,p;
rr.vendos_rrezen();
rr.llogarit();
rr.lexo(s,p);
cout<< "\nSipërfaqja s=" << s
<< "\nPerimetri p="<< p
<< "\n\n";
system("pause");
return 0;
}
162. Të shkruhet programi në të cilin shfrytëzohet klasa sfera me anëtarët
privat r, s, dhe v. Të llogaritet sipërfaqja dhe vëllimi i sferës dhe
rezultati të ruhet në anëtarët privat të klasës, s dhe v. Për të lexuar
vlerat e variablave s dhe v të shfrytëzohet funksioni lexo me parametrat
referentë x dhe y.
#include<iostream>
using namespace std;
const double pi=3.1415;
class sfera
{
double r,s,p;
public:
void vendos_rrezen();
void llogarit();
void lexo(double &x,double &y);
};
void sfera::vendos_rrezen()
{
cout << "\nRrezja r=";
cin >> r;
}
void sfera::llogarit()
{
s=4*pi*r*r;
p=(4/3)*pi*r*r*r;
}
void sfera::lexo(double &x,double &y)
{
x=s;
y=p;
}
int main()
{
sfera rr;
double s,p;
rr.vendos_rrezen();
rr.llogarit();
rr.lexo(s,p);
cout<< "\nSiperfaqja s=" << s

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
174
<< "\nVellimi v="<< p
<< "\n\n";
system("pause");
return 0;
}
7.6. Objektet referente
Objektet e strukturave dhe të klasave mund të deklarohen si objekte referente
plotësisht njëlloj, siç deklarohen edhe variablat e zakonshme. Si rezultat,
të dhënat që u shoqërohen anëtarëve të strukturave ose të klasave do të
barazohen me vlerat e anëtarëve përkatës në objektet të cilave u referohen.
163. Të shkruhet programi në të cilin është deklaruar struktura librat me
anëtarët: titulli, autori dhe funksioni shtypja. Të deklarohet objekti
referent libRef i objektit libri dhe më pas të thirret funksioni shtypja
përmes objektit libri dhe libRef.
#include <iostream>
#include <string>
using namespace std;
struct librat
{
string titulli;
string autori;
void shtypja();
};
void librat::shtypja()
{
cout<<"\nTitulli i librit: " <<titulli
<<"\nAutori i librit: " <<autori;
}
int main()
{
librat libri;
cout<<"Titulli i librit: ";
getline(cin,libri.titulli);
cout<<"Autori i librit: ";
getline(cin,libri.autori);
cout<<"Shtypja përmes objekit libri\n";
libri.shtypja();
librat &libRef=libri;
cout<<"Shtypja përmes objekit libRef\n";
libRef.shtypja();
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
175
164. Të shkruhet programi në të cilin është deklaruar klasa studentet me
anëtarët: emri, notat dhe funksionet për vendosje dhe shtypjen e vlerave
të anëtarëve. Të deklarohet objekti referent studRef i objektit stud. Duke
shfrytëzuar objektin dhe objektin referent të thirret funksioni i cili
shtyp emrin dhe notat e studentit.
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
class studentet
{
public:
string emri;
int notat[5];
void shtypja();
};
void studentet::shtypja()
{
cout<<"\nStudenti: "
<<emri <<"\nNotat: ";
for (int i=0;i<5; i++)
cout << setw(3)
<< notat[i];
}
int main()
{
studentet stud;
cout<<"Emri i studentit: ";
getline(cin,stud.emri);
for (int i=0;i<5; i++)
{
cout<< "Nota " <<i+1 <<": ";
cin >>stud.notat[i];
}
cout<<"\nShtypja permes objekit stud\n";
stud.shtypja();
studentet &studRef=stud;
cout<<"\n\nShtypja permes objekit studRef\n";
studRef.shtypja();
cout<<"\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
176
8. Fajllat
8.1. Fajllat me qasje sekuenciale
Fajllat tek të cilët të dhënat shkruhen ose lexohen si sekuenca (vargje)
bajtësh, paraqesin fajlla me qasje sekuenciale. Tek fajllat e tillë, si njësi
elementare që mund të shkruhet ose të lexohet është bajti. Zakonisht, tek
fajllat me qasje sekuenciale të dhënat shkruhen si tekste, prandaj këta
fajlla shpeshherë quhen edhe fajlla tekstualë.
Për të shkruar në fajll duhet të krijohet një objekt/rrjedhë e klasës
ofstream dhe të hapet fajlli. Për krijimin e objektit dhe hapjen e fajllit,
komandat përkatëse në formën themelore shkruhen:
Ku r – është rrjedha e deklaruar si objekt i klasave për punë me fajlla; f -
emri i fajllit që hapet; ios::out - modi i hapjes së fajllit për shkrim.
ios::in- modi i hapjes së fajllit për lexim. Skema e mëposhtme paraqet një
pamje vizuale për klasës ofstream dhe ifstream.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
177
165. Të shkruhet programi përmes së cilit lexohen tre numra nga fajlli
leximi.txt dhe më pas ruhen në variabla të ndara. Shuma e këtyre tre
numrave të shkruhet të fajllin shkrimi.txt.
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
ofstream shkruaj;
ifstream lexo;
int nr1, nr2, nr3;
lexo.open("leximi.txt", ios::in); //ifstream lexo("leximi.txt", ios::in);
if(!lexo) //kontrolli në fajlli është hapur
{
cout << "\nGabim gjatë hapjes së fajllit";
return 0;
}
lexo >> nr1 >> nr2 >> nr3;
shkruaj.open("shkrimi.txt", ios::out); //shkruaj.open("shkrimi.txt", ios::out);
shkruaj << "Shuma e tre numrave në "
<< "fajllin leximi.txt është "
<< (nr1 + nr2 + nr3)
<< endl;
lexo.close( );
shkruaj.close( );
system("pause");
return 0;
}
8.2. Qasja të fajllat në unazë
Komandat për shkrim dhe lexim në fajlla mund të përfshihen edhe brenda
unazave. Paraprakisht deklarohen rrjedhat si objekte të klasave përkatëse dhe
hapen fajllat. Për të shkruar në fajlla, të dhënat që fitohen përmes
llogaritjeve të ndryshme brenda unazave, komandat për shkrim përfshihen
brenda unazës. Për leximin e të dhënave të shkruara në më shumë rreshta duhet
të shfrytëzohet unaza, e ngjashme me unazën që është shfrytëzuar për shkrim.
166. Të shkruhet programi përmes së cilit në fajllin rrethi.txt ruhen të
dhënat e rrezes, sipërfaqes dhe perimetrit të rrethit për vlera të
ndryshme të rrezes nga 1 deri në 5 me hapin 1. Për shkrim të të dhënave të
përdoret manipulatori setw. Më pas të dhënat e shkruara në fajllin
rrethi.txt të lexohen dhe të shtypen në ekran.
#include <iostream>
#include <fstream>
#include <iomanip>
using namespace std;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
178
int main()
{
double pi=3.1415926,r,s,p;
ofstream shkruaj("rrethi.txt",ios::out);
for(int r=1;r<=5;r++)
{
s=2*pi*r;
p=pi*r*r;
shkruaj << setw(4)
<< r << ' '
<< setw(7) << s << ' '
<< setw(7) << p << endl;
}
cout << "\nShkrimi në fajll përfundoi\n\n";
ifstream leximi("rrethi.txt",ios::in);
cout << "\nTë dhënat e lexuara nga fajlli"
<< "\n\n r s p\n\n"
<< fixed << setprecision(2);
for(int i=1;i<=5;i++) //a dihet sa rreshta jane? Jo!
{
leximi>> r >> s >> p;
cout<< setw(4) << r
<< setw(7) << s
<< setw(7) << p
<< "\n";
}
leximi.close( );
shkruaj.close( );
system("pause");
return 0;
}
167. Të modifikohet shembulli paraprak duke përdorur vetëm një objekt edhe
për lexim edhe për shkrim. Leximi të bëhet deri sa nuk arrihet në fund të
fajllit.
//Shfrytëzimi i një objekti të vetëm
#include <iostream>
#include <fstream>
#include <iomanip>
using namespace std;
int main()
{
double pi=3.1415926,r,s,p;
fstream rrethi("rrethi.txt",ios::in|ios::out);
for(int r=1;r<=5;r++)
{
s=2*pi*r;
p=pi*r*r;
rrethi << setw(4)
<< r << ' '
<< setw(7) << s << ' '
<< setw(7) << p << endl;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
179
}
cout << "\nShkrimi në fajll përfundoi\n\n";
//pozita ne fajll; provoni edhe rrethi.seekp(0);
rrethi.seekg(0);
cout << "\nTë dhënat e lexuara nga fajlli"
<< "\n\n r s p\n\n"
<< fixed << setprecision(2);
while(!rrethi.eof())
{
rrethi>> r >> s >> p;
if(!rrethi.eof())
cout<< setw(4) << r
<< setw(7) << s
<< setw(7) << p
<< "\n";
}
rrethi.close();
system("pause");
return 0;
}
8.3. Tekstet dhe numrat në fajlla
Në fajlla mund të shkruhen dhe të lexohen edhe tekste edhe numra,
përkatësisht stringje. Vlerat numerike që shkruhen në fajll mund të
shoqërohen edhe me tekste, plotësisht njëlloj siç shoqërohen edhe gjatë
shtypjes në ekran. Por, këtu duhet pasur kujdes që në mes të dhënave të
veçanta të lihet së paku një hapësirë, në mënyrë që të dallohen të dhënat e
veçanta.
168. Të shkruhet programi përmes së cilit shkruhet së paku një fjali në
fajllin teksti.txt. Më pas të lexohet përmbajtja e këtij fajlli dhe të
shtypet në ekran duke shfrytëzuar një variabël të tipit string.
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main()
{
// -------------- Shkrimi në fajll ------------
ofstream shkruaj("teksti.txt",ios::out);
shkruaj << "Universiteti i Prishtinës - FIEK";
cout << "\nShkrimi në fajll përfundoi\n";
shkruaj.close();
// -------------- Leximi nga fajlli -----------
string str;
ifstream Lexo("teksti.txt",ios::in);
cout << "\nTeksti i lexuar nga fajlli\n\n";
while (!Lexo.eof())

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
180
{
Lexo >> str;
cout<< str << endl;
//cout<< str <<' ';
//cout<< str ;
}
cout << "\nLeximi nga fajlli përfundoi\n\n";
system("pause");
return 0;
}
169. Të shkruhet programi përmes së cilit në një fajll shkruhen dy variabla
të shoqëruara me vlerat e tyre (pamja 1). Më pas të lexohen këto të dhëna
dhe të shtypen në ekran (pamja 2).
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main()
{
int v1=2013;
double v2=23.05;
ofstream shkruaj("numrat.txt",ios::out);
shkruaj << "v1= " << v1
<< " v2= " << v2;
cout << "\nShkrimi në fajll përfundoi\n\n";
shkruaj.close();
int a; double b;
string s1,s2;
ifstream lexo("numrat.txt",ios::in);
lexo>> s1
>> a
>> s2
>> b;
cout << "\nTë dhënat e lexuara nga fajlli\n\n"
<< s1
<< a
<< "\n"
<< s2
<< b
<< "\n\n";
lexo.close();

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
181
system("pause");
return 0;
}
170. Të shkruhet programi përmes së cilit në fajllin data.txt shkruhen
vlerat e tri variablave (char, int, double) dhe vlerat e dy variablave
string.
#include <fstream>
#include <iostream>
#include <string>
using namespace std;
int main()
{
char k = 'x';
int n = 77;
double d = 6.02;
string emri = "Vehbi";
string mbiemri = "Neziri";
ofstream outfile("data.txt");
outfile << k //shkrimi i të dhënave
<< n << ' ' //hapësira në mes numrave
<< d
<< emri
<< ' ' //hapësira në mes stringjeve
<< mbiemri;
cout << "Të dhënat u ruajten në fajll\n";
system("pause");
return 0;
}
171. Të shkruhet programi përmes së cilit lexohen të dhënat e shkruara
përmes shembullit paraprak.
include <fstream>
#include <iostream>
#include <string>
using namespace std;
int main()
{
char k;
int n;
double d;
string emri;
string mbiemri;
ifstream infile("data.txt");
//ekstrakto (lexo) te dhenat nga fajlli
infile >> k
>> n
>> d
>> emri
>> mbiemri;
cout << k
<< endl //shfaq te dhenat

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
182
<< n << endl << d << endl
<< emri << endl
<< mbiemri << endl;
system("pause");
return 0;
}
8.4. Shkrimi dhe leximi i karaktereve
Për shkrimin e të dhënave apo leximin e tyre nga fajlli si karaktere, mund të
shfrytëzohen funksionet put dhe get. Në formë të përgjithshme, versionet
themelore të këtyre dy funksioneve duken si më poshtë, ku k është karakteri
që shkruhet ose lexohet:
Vlera e k mund të jetë edhe numër, p.sh cout.put(65); do të vendos shkronjën
A, pasi që 65 është kodi ASCII i shkronjës A.
172. Të shkruhet programi i cili tekstin e dhënë në një string e shkruan në
fajll duke përdorur funksionin put(). Më pas teksti i shkruar në fajll të
lexohet përmes funksionit get() dhe të shfaqet në ekran.
#include <fstream>
#include <iostream>
#include <string>
using namespace std;
int main()
{
string str = "Nëse rrezikon mund të humbasësh, "
"nëse nuk rrezikon ke humbur gjithsesi";
ofstream shkruaj("putget.txt");
for(int i=0; i<str.size(); i++) //për secilin karakter,
shkruaj.put(str[i] ); //shkruaj në fajll
cout << "Fajlli u shkrua\n";
shkruaj.close();
char ch;
ifstream lexo("putget.txt");
while(lexo ) //lexo deri në fund të fajllit
{
lexo.get(ch); //lexo karakterin
if(lexo)
cout << ch; //shfaqe karakterin e lexuar
}
cout << endl;
lexo.close();

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
183
system("pause");
return 0;
}
173. Të shkruhet programi i cili tekstin e dhënë përmes tastiere e lexon
deri tek karakteri i caktuar dhe të njëjtin e ruan në fajllin
karakteri.txt. Më pas, teksti të lexohet nga fajlli dhe të shtypet në
ekran.
#include <iostream>
#include <fstream>
using namespace std;
int main ()
{
ofstream shkruaj ("karakteri.txt", ios::out);
char k;
cout << "Shëno një fjali (përdor . per të përfunduar):\n";
do
{
k = std::cin.get();
shkruaj.put(k);
}while (k!='.');
shkruaj.close();
ifstream lexo("karakteri.txt",ios::in);
cout << "\nFjalia e lexuar nga fajlli\n\n";
while (lexo.good())
{
char c = lexo.get();
if (lexo.good())
cout << c;
}
lexo.close();
system("pause");
return 0;
}
8.5. Leximi i rreshtave
Nga fajllat mund të lexohen rreshtat komplet, përfshirë edhe hapësirat që
mund të paraqiten brenda tyre. Gjithashtu, të dhënat në këta rreshta mund të
lexohen deri në paraqitjen e një simboli të caktuar. Në të dy këto raste, për
leximin e të dhënave nga fajlli, shfrytëzohet funksioni getline.
Ku, str – është baferi në të cilin ruhet teksti i lexuar; max - gjatësia e
stringut që lexohet; delim - Karakteri ndarës ose kufitar (delimiter).

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
184
174. Të shkruhet programi përmes së cilit shkruhet disa rreshta tekst të
çfarëdoshëm në fajllin getline.txt. Më pas këta rreshta të tekstit të
lexohen përmes funksionit getline dhe të shtypen në ekran.
#include <fstream>
#include <iostream>
using namespace std;
int main()
{
ofstream shkruaj("getline.txt");
shkruaj << "Kur s'ke kokë, ke këmbë.\n";
shkruaj << "Mate shtatë herë, e preje një herë.\n";
shkruaj << "Cdo hap drejt kulturës, është hap drejt lirisë.\n";
shkruaj.close();
const int max = 80;
char buffer[max]; //bufer
ifstream lexo("getline.txt");
while(!lexo.eof() )
{
lexo.getline(buffer, max); //lexo një rresht
lexo.getline(buffer,max,'ë'); //lexo deri në karakterin 'ë'
cout << buffer << endl; //shfaqe rreshtin
}
system("pause");
return 0;
}
8.6. Mode të hapjes së fajllave
Fajllat mund të hapen në mode të ndryshme, në varësi se për ëka nevojiten,
për shkrim, lexim, modifikim.
Modi i hapjes
Përshkrimi
in
Hapet fajlli për lexim.
out
Hapet fajlli për shkrim.
trunc
Fshihet përmbajtja e fajllit.
app
Fillo shkrimin në fund të fajllit (append).
nocreate
Nëse fajlli nuk ekziston, hapja e tij dështon.
noreplace
Nëse fajlli ekziston, hapja e tij dështon.
ate
Fillo leximin ose shkrimin në fund të fajllit.
binary
Hapet fajlli si fajll binar.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
185
175. Të shkruhet programi përmes së cilit shtohet tekst në fajllin
ekzistues append.txt. Më pas, përmes një objekti tjetër të shkruhen disa
rreshta tekst në fajllin binar.bin e të hapur në modin binar.
#include <fstream>
#include <iostream>
using namespace std;
int main()
{
//-----------modi append------------------
cout << "Teksti do të shkruhet në vazhdim të"
" përmbajtes ekzistuese\n";
ofstream shkruaj;
shkruaj.open("append.txt", ios::app);
shkruaj << "Filan Fisteku\n";
shkruaj.close( );
cout << "Shtimi i studentit u krye.\n";
//-----------modi binar------------------
ofstream binar("binar.bin",ios::out|ios::binary);
binar << "Rreshti i parë\n";
binar << "Rreshti i dytë\n";
cout << "\nShkrimi në fajllin binar përfundoi\n\n";
system("pause");
return 0;
}
176. Të shkruhet programi përmes së cilit në fajllin ekzistues i cili
përmban disa emra të shtohen edhe disa emra të rinj. Gjatë hapjes së
fajllit të shtypet përmbajtja ekzistuese, kurse pas regjistrimit të emrave
të rinj të shtypet përsëri përmbajtja e fajllit.
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
const char * fajlli = "emrat.txt";
int main()
{
char ch;
ifstream lexo;
lexo.open(fajlli);
if (lexo.is_open())
{
cout << "Permbajtja aktuale e fajllit " << fajlli << ":\n";
while (lexo.get(ch))
cout << ch;
lexo.close();
}
ofstream shkruaj(fajlli, ios::out | ios::app);
if (!shkruaj.is_open())
{
cout << "Fajlli " << fajlli << " nuk mund te hapet.\n";

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
186
exit(EXIT_FAILURE);
}
cout << "Sheno emrat e rinj (rresht i zbrazur per ta perfunduar):\n";
string name;
while (getline(cin,name) && name.size() > 0)
{
shkruaj << name << endl;
}
shkruaj.close();
lexo.open(fajlli);
if (lexo.is_open())
{
cout << "Permbajtja e ndryshuar e fajllit " << file << ":\n";
while (lexo.get(ch))
cout << ch;
lexo.close();
}
system("pause");
return 0;
}
8.7. Pozita në fajll
Pozita në të cilën shkruhen ose lexohen të dhënat nga fajlli, përcaktohet me
pozitën e pointerit në fajll. Sa herë që shkruhet ose lexohet në fajll,
pointeri i pozitës në fajll rritet automatikisht. Pozita e pointerit në fajll
mund të përcaktohet edhe direkt, duke i shfrytëzuar funksionet: seekp() dhe
seekg().
177. Të shkruhet programi përmes së cilit lexohet karakteri i cili gjendet
në pozitën e dhënë përmes tastierës.
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
int p;
char k;
fstream pozita("pozita.txt",ios::out|ios::in|ios::trunc);
pozita << "Ky shembull mundëson leximin e "
"karakterit në pozitën e caktuar\n";
cout << "\nJep pozitën e karakterit që dëshiron të lexohet: ";
cin >> p;
pozita.seekg(p);
pozita.get(k);
cout << "\nKarakteri në bajtin me numër rendor "
<< p
<< " është: "
<< k

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
187
<< "\n\n";
//për ta lexuar pozitën aktuale ne fajll
//përdoret tellg(); p.sh pozita.tellg();
system("pause");
return 0;
}
178. Të shkruhet programi përmes së cilit lexohet nga një fajll tekstual.
Pointeri të zhvendoset në pozita të ndryshme dhe të lexohen karakteret që
gjendet në ato pozita.
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
char ch;
ifstream fajlli;
fajlli.open("alfabeti.txt");
if (!fajlli)
{
cout << "Fajlli nuk ekziston. " << endl;
system("pause");
return 1;
}
fajlli.get(ch);
cout << "Bajti i parë: " << ch << endl;
fajlli.seekg(6, ios::cur);
fajlli.get(ch);
cout << "Bajti tek pozita 6: " << ch << endl;
fajlli.seekg(7, ios::beg);
fajlli.get(ch);
cout << "Bajti i shtatë prej fillimi: " << ch << endl;
fajlli.seekg(-26, ios::end);
fajlli.get(ch);
cout << "Bajti i 26 prej fundi: " << ch << endl;
system("pause");
return 0;
}
8.8. Fajllat me qasje direkte
Për qasje direkte tek të dhënat e përfshira në fajlla shfrytëzohen fajllat me
qasje direkte. Në praktikë, fajllat e tillë deklarohen si fajlla binarë duke
shfrytëzuar regjistrime me gjatësi fikse. Të dhënat individuale të një fajll
me qasje të rastit mund të arrihen drejtpërdrejt (dhe shpejt), pa kërkuar
shumë shënime të tjera.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
188
Tek fajllat me qasje direkte, të dhënat shkruhen ose lexohen si blloqe të
dhënash, duke i shfrytëzuar funksionet write dhe read. Hapësira memoruese, e
cila shfrytëzohet në fajll për ruajtjen e të dhënave të veçanta, është fikse
dhe varet nga tipi i variablave përkatëse. P.sh. për ruajtjen e vlerës
12345678 të një variable të tipit int, në fajll do të shfrytëzohet hapësirë
4-bajtëshe, gjë që dallon nga fajllat me qasje sekuenciale, tek të cilët
numri i njëjtë vendoset në 8-bajtë (për çdo shifër shfrytëzohet 1 bajt).
Forma e përgjithshme e këtyre funksioneve është dhënë në vijim:
Ku &v – është adresa e variablës v, vlera e së cilës shkruhet në fajll;
sizeof(v) - numri i bajtëve tek të cilët shkruhet vlera e variablës v.
179. Të shkruhet programi përmes së cilit vlera e variablës a shkruhet në
fajllin me qasje direkte direkt.bin. Më pas të deklarohet një variabël b
dhe vlera e lexuar nga fajlli të i shoqërohet kësaj variable.
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
//------shkrimi në fajll------------------------
int a=12345678;
ofstream shkruaj ("direkt.bin",ios::out|ios::binary);
shkruaj.write((char*) &a,sizeof(a));
shkruaj.close();
cout << "\nShkrimi ne fajll përfundoi\n\n";
//------leximi nga fajlli------------------------
int b;
ifstream lexo("direkt.bin",ios::in|ios::binary);
lexo.read((char*) &b,sizeof(b));
cout<< "\nVlera e lexuar nga fajlli b="
<< b
<< "\n\n";
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
189
180. Të shkruhet programi i cili duke përdorur operatorin sizeof përcakton
madhësinë në bajt për tipat e ndryshëm të të dhënave. Rezultati të ruhet
në fajllin me emrin madhësia.txt.
#include <fstream>
#include <iostream>
using namespace std;
#include <iomanip>
int main()
{
char v[]="\n-----------------------------------\n";
ofstream shkruaj( "madhesia.txt" );
if ( !shkruaj )
{
cout << "Nuk mund të hapet fajlli \"madhesia.txt\".\n";
exit(0);
}
shkruaj << "Tipi i të dhenave" << setw(12) << "Madhësia"
<<v
<<"char" << setw(21) << sizeof( char )
<< "\nunsigned char" << setw(12) << sizeof( unsigned char )
<< "\nshort int" << setw(16) << sizeof( short int )
<< "\nunsigned short int" << setw(7) << sizeof( unsigned short)
<< "\nint" << setw(22) << sizeof(int) << '\n'
<< "unsigned int" << setw(13) << sizeof(unsigned)
<< "\nlong int" << setw(17) << sizeof( long )
<< "\nunsigned long int" << setw(8) << sizeof( unsigned long )
<< "\ndouble" << setw(19) << sizeof( double )
<< "\ndouble" << setw(19) << sizeof( double )
<< "\nlong double" << setw(14) << sizeof( long double )
<<v
<< endl;
shkruaj.close();
return 0;
}
8.9. Vlerat e fushave në fajlla
Në fajllat me qasje direkte mund të shkruhen vlerat e fushave një
dimensionale (vektorëve), fushave dy dimensionale (matricave), ose edhe të
fushave shumëdimensionale. Komandat të cilat përdoren për shkrim/lexim të
fushave në fajlla me qasje direkte nuk dallojnë nga ato të shfrytëzuara gjatë
shkrim/leximit të vlerave të variablave të zakonshme. Hapësira në të cilën
shkruhet/lexohet fusha në fajll përcaktohet duke e shumëzuar numrin e
anëtarëve të fushës dhe numrin e bajtëve që shfrytëzohen prej tyre, p.sh
sizeof(int).

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
190
181. Të shkruhet programi përmes së cilit vlerat e vektorit A shkruhen në
fajllin vektori.bin. Më pas vlerat e vektorit të lexohen nga fajlli dhe të
shtypen në ekran.
#include <fstream>
#include <iostream>
using namespace std;
const int m=6;
int main()
{
int i,A[m]={3,4,-1,-5,5,8};
// ---Shkrimi ne fajll i vlerave të vektorit -----
ofstream shkruaj ("vektori.bin",ios::out|ios::binary);
shkruaj.write((char*) &A,sizeof(A));
cout << "\nShkrimi ne fajll perfundoi\n\n";
shkruaj.close();
/*Për tu siguruar se vlerat lexohen nga fajlli
provoni që vlerat e vektorit të bëhen zero A[i]=0 */
// ------ Leximi i vektorit nga fajlli -----------------
ifstream lexo("vektori.bin",ios::in|ios::binary);
lexo.read((char*) &A,sizeof(A));
// ------ Shtypja e vektorit në ekran ------------------
cout << "\nVlerat e lexuara nga fajlli:\n";
for (i=0;i<m;i++)
cout<< "\n A["
<< i
<< "]="
<< A[i];
cout << "\n\n";
system("pause");
return 0;
}
182. Të shkruhet programi përmes së cilit vlerat e matricës Mat shkruhen në
fajllin matrica.bin. Më pas vlerat e matricës të lexohen nga fajlli dhe të
shtypen në ekran.
#include <fstream>
#include <iostream>
#include <iomanip>
using namespace std;
const int m=4, n=3;
int main()
{
int Mat[m][m]={
{3,-1,4},
{3, 6,2},
{2,-5,6},
{3, 4,9}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
191
};
ofstream shkruaj;
shkruaj.open("matrica.bin", ios::out | ios::binary);
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (Mat[i][j] != 0)
{
shkruaj.write (reinterpret_cast<char*> (&Mat[i][j]), sizeof(int));
}
}
}
shkruaj.close();
ifstream lexo;
lexo.open("matrica.bin", ios::in | ios::binary);
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
lexo.read (reinterpret_cast<char*> (&Mat[i][j]), sizeof(int));
cout<<setw(3)<<Mat[i][j];
}
cout<<endl;
}
lexo.close();
system("pause");
return 0;
}
8.10. Objektet në fajlla
Të dhënat e përfshira në anëtarët e strukturave ose të klasave mund të
lexohen ose të shkruhen në fajlla me qasje sekuenciale, ose edhe në fajlla me
qasje direkte.
183. Të shkruhet programi në të cilin deklarohet struktura studentet (emri,
indeksi, vendi). Vlerat e anëtarëve të merren përmes tastiere dhe më pas
duke shfrytëzuar objektin e strukturës këto të dhëna të shkruhen dhe të
lexohen nga fajlli me qasje direkte i quajtur objekti.dat.
#include <fstream>
#include <iostream>
#include <string>
using namespace std;
struct studentet
{
string emri;
string indeksi;
string vendi;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
192
};
int main()
{
studentet ob_sh;
cout << "Emri dhe mbiemri: ";
getline(cin,ob_sh.emri);
cout << "Numri i indeksit: ";
getline(cin,ob_sh.indeksi);
cout << "Vendbanimi: ";
getline(cin,ob_sh.vendi);
//shkrimi në fajll i i vlerave të anëtarëve të objektit stud
ofstream shkruaj("objekti.dat",ios::out|ios::binary);
shkruaj.write((char *)(&ob_sh),sizeof(ob_sh));
shkruaj.close();
cout<<"\nShkrimi i të dhënave të anëtarëve të strukturës përfundoi"
<<"\n\nLeximi i të dhënave nga fajlli\n\n";
//leximi i të dhënave dhe vendosja në anëtarët e objektit stud
ifstream lexo("objekti.dat",ios::in|ios::binary);
lexo.read((char *)(&ob_sh),sizeof(ob_sh));
lexo.close();
// shtypja e të dhënave në ekran
cout<<"Emri: " <<ob_sh.emri<<endl;
cout<<"Indeksi: " <<ob_sh.indeksi<<endl;
cout<<"Vendi:"<< ob_sh.vendi<<endl;
system("pause");
return 0;
}
184. Të shkruhet programi në të cilin duke përdorur strukturën presidenti
(id, emri, mbiemri, qyteti, viti lindjes, titulli), të dhënat presidentit
që cilat merren përmes tastiere shkruhen në fajllin binar
“presidenti.bin”.
#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;
struct presidenti
{
int idkandidat;
string emri;
string mbiemri;
string qyteti;
int vitilindjes;
string titulli;
} pres;
void ruaj_kandidat(ofstream &rrjedha)
{
rrjedha.write(reinterpret_cast<char*>(&pres), sizeof(pres));

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
193
rrjedha.close();
}
void regjistro_kandidat()
{
cout<<"ID: " ; cin>>pres.idkandidat;
cout<<"Emri: " ; cin>>pres.emri;
cout<<"Mbiemri: " ; cin>>pres.mbiemri;
cout<<"Qyteti: " ; cin>>pres.qyteti;
cout<<"Viti lindjes: " ; cin>>pres.vitilindjes;
cout<<"Titulli: " ; cin>>pres.titulli;
}
int main()
{
ofstream rrjedha("presidenti.dat", ios::binary|ios::app);
if(!rrjedha)
{
cout << "Fajlli nuk eshte gjendur ose nuk mund te hapet!" << endl;
return 0;
}
else
{
cout << "Regjistrimi i kandidateve per president. \n\n";
char pyet;
do
{
regjistro_kandidat();
ruaj_kandidat(rrjedha);
cout<<"A deshiron te regjistrosh kandidat tjeter? (Po=p, Jo=j)";
cin>>pyet;
} while (pyet!='j' || pyet!='J');
}
system("pause");
return 0;
}
185. Të shkruhet programi në të cilin duke përdorur strukturën presidenti,
të deklaruar në shembullin paraprak, të lexohen të dhënat e kandidatëve
për president dhe të shtypen në ekran.
#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;
struct presidenti
{
int idkandidat;
string emri;
string mbiemri;
string qyteti;
int vitilindjes;
string titulli;
} pres;
void shfaq_kandidat()

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
194
{
cout<<"ID: " <<pres.idkandidat;
cout<<"\nEmri: " <<pres.emri;
cout<<"\nMbiemri: " <<pres.mbiemri;
cout<<"\nQyteti: " <<pres.qyteti;
cout<<"\nViti lindjes: "<<pres.vitilindjes;
cout<<"\nTitulli: " <<pres.titulli<<endl<<endl;
}
void lexo_kandidat(ifstream &rrjedha)
{
while(rrjedha.read((char *) (&pres), sizeof(pres)))
{
shfaq_kandidat();
}
rrjedha.close();
}
int main()
{
ifstream rrjedha("presidenti.dat", ios::binary);
if(!rrjedha)
{
cout << "Fajlli nuk është gjendurr ose nuk mund të hapet!" << endl;
return 0;
}
else
{
lexo_kandidat(rrjedha);
}
system("pause");
return 0;
}
186. Të shkruhet programi në të cilin deklarohet klasa personi (emri,
mosha). Vlerat e anëtarëve të merren përmes tastiere dhe më pas duke
shfrytëzuar objektin e klasës, këto të dhëna të shkruhen dhe të lexohen
nga fajlli me qasje direkte i quajtur personi.dat.
#include <fstream>
#include <iostream>
using namespace std;
class personi
{
protected:
char emri[30];
short mosha;
public:
void vendos_vlerat()
{
cout << "Emri dhe mbiemri: "; cin.getline(emri,30);
cout << "Mosha: "; cin >> mosha;
}
void lexo_vlerat()
{
cout << "\nEmri dhe mbiemri: "<< emri;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
195
cout << "\nMosha: "<< mosha;
}
};
//reinterpret_cast përdoret për konvertimin
// e adresës së objektit në char
int main()
{
personi pers;
pers.vendos_vlerat();
//shkrimi i të dhënave të objektit pers në fajll
ofstream shkruaj("personi.dat", ios::binary);
shkruaj.write(reinterpret_cast<char*>(&pers), sizeof(pers));
shkruaj.close();
//leximi i të dhënave nga fajlli dhe
// vendosja e tyre në objektin pers
ifstream lexo("personi.dat", ios::binary);
lexo.read(reinterpret_cast<char*>(&pers), sizeof(pers));
lexo.close();
// shtypja e të dhënave në ekran
pers.lexo_vlerat();
cout<<endl;
system("pause");
return 0;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
196
9. Pyetje dhe shembuj vetë-testues
9.1. Funksionet
1. A paraqet prototip të funksionit apo thirrje të funksionit rreshti i
mëposhtëm?
totali();
2. A paraqet prototip të funksionit apo thirrje të funksionit rreshti i
mëposhtëm?
void rezultati();
3. Cili prototip është i shkruar saktë?
a. void numri(double);
b. numri(10.55);
4. Sa vlera mund të kthejë një funksion në C++?
a. 1
b. 2
c. Shumë
d. Asnjë
5. Kur funksioni merr më shumë se një parametër, a ka rëndësi renditja e tyre
gjatë thirrjes së funksionit?
6. A mundet funksioni të ketë variabël me emrin e njëjtë sikurse variabla
globale?
7. Gjej gabimet në funksionin e mëposhtëm.
void totali(int v1, v2, v3)
{
return v1 + v2 + v3;
}
8. Gjej gabimet në funksionin e mëposhtëm.
double mesatarja(int v1, int v2, int v3)
{
double average;
average = v1 + v2 + v3 / 3;
}

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
197
9. Shkruaj prototipin e funksionit dhe krijimin e tij i cili merr tre
parametra (argumente) int dhe kthen si rezultat shumën e tyre.
10. Shkruaj deklarimin dhe krijimin e funksionit i cili merr një parametër
të tipit double. Funksionin duhet të kthej 'P' nëse parametri është
pozitiv dhe 'N' nëse parametri është negativ.
11. Të shkruhet funksionin void i cili ka tre parametra të tipit int dhe i
cili shtyp në ekran prodhimin e tre parametrave.
12. Të shkruhet funksioni i cili ka një parametër të tipit char dhe i cili
kthen true nëse parametri është numër, dhe false nëse parametri nuk është
numër.
13. Supozoni se funksioni funksioni1 e ka një variabël të deklaruar
përbrenda tij me emrin shuma, por edhe funksioni2 e ka të deklaruar
variablen me të njëjtin emër shuma.
a. A do të kompilohet programi?
b. A do të ekzekutohet programi?
14. Nëse një variabël përdoret vetëm tek një funksion, ku duhet të
deklarohet ajo?
a. Në të njëjtin funksion?
b. Në funksionin main?
c. Në çdo pjesë të kodit?
15. Të shkruhet shprehja e cila ia shoqëron variablës n një numër të plotë
të gjeneruar në mënyrë të rastësishme.
a.
b.
16. Të shkruhet shprehja për secilin grup e cila do të shtyp numrat e
rastit nga grupi.
c. 2, 4, 6, 8, 10
d. 6, 10, 14, 18, 22
17. Një parking e ka tarifën e parkingut 1Euro deri në 3 orë dhe më pas çdo
orë nga 0.5Euro. Maksimumi i pagesës për 24 orë është 5 euro. Të shkruhet
funksioni i cili llogarit koston e parkingut për disa vetura të cilat janë
parkuar në kohë të ndryshme (të jepet para sa orësh janë parkuar). Më pas
të printohet kostoja për secilën veturë dhe totali për të gjitha veturat.
18. Të shkruhet programi i cili i pranon 10 numra përmes tastiere dhe i
ruan në një vektor. Vektori të jetë parametër i një funksioni i cili e
shtyp në ekran numrin më të madh dhe më të vogël.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
198
19. Të shkruhet programi i cili përmes një funksioni i cili ka si parametër
numrin e minutave e kthen rezultatin në orë. P.sh nëse kemi 90 minuta të
kthehet rezultati 1 orë e 30 minuta.
20. Të shkruhet programi i cili përmes një funksioni i konverton numrat
romak në numra decimal.
9.2. Numerimet
1. Çka është enumeration dhe grupim i kujt është?
2. Nëse deklarimet e mëposhtme janë pjesë e një programi të rregullt, çfarë
do të shtypet pas ekzekutimit.
enum drejtimi { V, J, L, P };
// ...
cout << P << " " << L << " "
<< J << " " << V << endl;
3. Nëse deklarimet e mëposhtme janë pjesë e një programi të rregullt, çfarë
do të shtypet pas ekzekutimit.
enum drejtimi { V=3, J, L=6, P };
// ...
cout << P << " " << L << " "
<< J << " " << V << endl;
4. Të deklarohet një grup me emrin qytetet i cili përmban qytetet e Kosovës.
5. Enumeration janë:
a) konstante
b) tipa të dhëna të përcaktuara nga përdoruesi
c) karaktere
6. Enumeration ruhen nga kompajleri si:
a) string
b) integer
c) float
7. Çka ndodh kur të krijohet një enumeration (grup)?
a) Rezervohet memorie
b) Nuk rezervohet memorie
c) Nuk rezervohet memorie për variablën e grupit

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
199
8. Të shkruhet një program i cili simulon punën e semaforëve të trafikut. Të
përdoret një enumeration për ngjyrat e semaforit. Programi të përseritet
për një numër të caktuar të cikleve.
9. Të shkruhet një programi i cili në një enumeration/grup definon tipat e
gabimeve të mundshme për programin e shkruar dhe më pas duke përdorur
vlerat e grupit të shfaqet lloji i gabimit.
10. Të shkruhet programi dhe të deklarohet një grup/enumeration me emrin
nota i cili si anëtarë ka notat nga pesë deri në dhjetë. Secilit anëtar të
i shoqërohet vlera numerike. Të lexohen vlerat e anëtarëve të grupit dhe
të ruhen në një vektor.
9.3. Sinonimet
1. Të deklarohet sinonime të ndryshme për tipat klasik të të dhënave.
9.4. Strukturat
1. Të shkruhet programi dhe të krijohet një strukturë e të dhënave e quajtur
Vetura e cila përmban dy anëtarë: një anëtarë int për vitin dhe një fushë
double për shpenzimet e derivateve për 100km. Në program të deklarohet një
makinë dhe të caktohen vlerat për të si dhe të shfaqen në ekran.
2. Të shkruhet programi dhe të krijohet një strukturë e të dhënave Fakulteti
e cila përmban anëtarët për vitin e themelimit, numrin e studentëve dhe
pagesën vjetore të shkollimit: Të dhënat tç lexohen përmes tastiere dhe më
pas të shtypen në ekran.
3. Të shkruhet programi dhe të krijohet një strukturë e të dhënave Kompjuteri
e cila përmban disa anëtarë për karakteristikat e kompjuterit. Në program
të krijohen dy kompjuterë dhe më pas të krahasohen disa nga
karakteristikat e kompjuterëve.
4. Nëse është dhënë struktura katrori
struct katrori
{
int gjeresia
int gjatesia
};
Të shkruhet funksioni i cili shfaq përmbajtjen e strukturës. Funksioni ka si
parametër strukturën katrori.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
200
5. Të deklarohet një strukturë me emrin Llogaria e cila mban të dhënat për
një llogari bankare. Të përfshihet konstruktori i cili lejon që anëtarët
të inicohen me vlera. Më pas të shtypen në ekran të dhënat e klientit.
6. Të deklarohet një strukturë me emrin ShkallaTemp me anëtarët Fahreiheit
dhe Celsius. Struktura tjetër të jetë Leximi me anëtarët shpejtesiEra,
Lageshtia dhe variabla e strukturës ShkallaTemp. Në funksionin main të
deklarohet variabla e strukturës Leximi dhe të shtypet të dhënat si në
vijim:
 Shpejtësia e erës: 35 m/h
 Lagështia 29%
 Temperatura në Fahreinheit: 89.6
 Temperatura në Celsius: 32
7. Të shkruhet programi i cili ka një funksion me parametër strukturën Leximi
(detyra paraprake) dhe i cili shtyp në ekran të dhënat për motin.
8. Të shkruhet programi dhe të krijohet struktura e cila mban listën e
emailave. Përmes një funksioni të shtypet lista e emailave.
9. Të shkruhet programi në të cilin krijohet një strukturë për të mbajtur të
dhënat për rezervimet e biletave të aeroplanit. Të dhënat e nevojshme
janë:
 Numri i fluturimit
 Kodi i aeroportit të nisjes
 Kodi i aeroportit të destinacionit
 Koha e nisjes
 Koha e arritjes
 Çmimi i biletës
10. Nëse buxheti mujor i një studenti është si më poshtë:
 Banimi: 150€
 Shërbime publike: 30€
 Transporti: 25€
 Ushqimi: 90€
 Veshmbathje: 50€
 Tjera: 50€
Të shkruhet programi që deklaron një strukturë BuxhetiMujor me anëtarë për të
mbajtur vlerat e kategorive të mësipërme. Në program të deklarohen dy
variabla të strukturës; njëra me vlerat e dhëna më lart dhe tjetra me vlera
të ndryshme. Përmes një funksioni i cili ka si parametra formalë dy variablat
e strukturës së krahasohen shpenzimet e variablës së parë dhe të dytë dhe të
tregohet se për cilat kategori është tejkaluar buxheti e për cilat jo.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
201
9.5. Klasat
1. Cili është dallimi teknik në mes strukturave dhe klasave?
2. Të përmirësohet gabimi për klasën e mëposhtme:
class fiek
{
public:
void printo()const;
shuma();
fiek();
int fiek(int, int);
private:
int x;
int y;
};
3. Të krijohet një klasë me emrin drejtkendeshi. Klasa të ketë anëtarët
privat gjatesia dhe gjeresia të cilët kanë vlera të nënkuptuara 1.0 dhe
anëtarët publik për llogaritjen e sipërfaqes dhe perimetrit të
drejtkëndëshit. Klasa, po ashtu duhet të ketë funksionet për vendosjen dhe
marrjen e vlerave të gjatësisë dhe gjerësisë. Funksionet për vendosjen e
vlerës duhet të verifikojnë që gjatësia dhe gjerësia të jenë më mëdha se
0.0 dhe më të vogla se 20.00, në të kundërtën vlerat të vendosen në 0.0.
a. Të implementohet klasa drejtkendeshi me anëtarët e cekur në
përshkrimin në të majtë.
b. Të implementohet funksioni për llogaritjen e sipërfaqes dhe
perimetrit të drejtkëndëshit si dhe funksionet për vendosjen dhe
marrjen e vlerave të gjatësisë dhe gjerësisë.
c. Të implementohet funksioni main në të cilin deklarohen tre objekte
të klasës drejtkendeshi dhe thirren për vlera të ndryshme. Objekti
i parë të thirret me vlerat e nënkuptuara, objekti i dytë me çfarëdo
vlerash dhe objekti i tretë me vlera më të mëdha se 0 ose më të
vogla se 20.
4. Anëtarët e klasës mund të jenë?
a) Variabla
b) Funksione
c) Edhe variabla edhe funksione
d) Asnjëra
5. Kodi i mëposhtëm ka gabime. Të gjenden dhe të përmirësohen gabimet.
class fiek
{
public:
void printo()const;
shuma();
fiek();
int fiek(int, int);
private:
int x;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
202
int y;
};
6. Të implementohet klasa shitja me anëtarin privat taksa dhe anëtarin
publik, funksionin shitjaTotale i cili kthen çmimin së bashku me taksë.
Klasa të ketë konstruktorin e nënkuptuar i cili vendos taksen në zero dhe
konstruktorin i cili vendos taksen në vlerën e caktuar.
a. Të implementohet klasa shitja sipas përshkrimit të sipërm.
b. Të implementohet funksioni main dhe të deklarohen dy objekte.
Objekti i parë nuk ka parametër, kurse objekti i dytë e ka si
parametër taksën e cila jepet në përqindje.
7. Të krijohet një enumeration ngjyrat (kuqe, kaltër, verdhë, portokalli,
vjollce) dhe klasa perzierja e cila përmban një anëtar me të dhëna të
tipit ngjyrat si dhe konstruktorin i cili vendos vlerën e anëtarit nga
parametri i tij.
8. Të shkruhet programi dhe të deklarohet klasa Data e cila ka anëtarët për
ruajtjen e ditës, muajit dhe vitit. Klasa të ketë konstruktorin e
nënkuptuar (default) dhe konstruktorin me tre parametra i cili e vendos
datën gjatë krijimit të objektit. Nëse objekti krijohet pa parametra, ose
vlerat e vendosura janë jo të sakta, atëherë data të vendoset në 1.1.2000.
Klasa të ketë funksionin Formato i cili e printon datën në njërin nga
formatet e zgjedhura si më poshtë:
 17/02/2008
 17 Shkurt 2008
 17.02.2008
9. Llogaritja e shkallës së lindjeve dhe të vdekjeve të një popullsie është
bërë si më poshtë:
 Shkalla e lindjeve = numri i lindjeve / numri i popullsisë
 Shkalla e vdekjeve = numri i vdekjeve / numri i popullsisë
Të shkruhet programi dhe të deklarohet klasa Popullsia e cila ruan numrin e
popullsisë, numrin e lindjeve dhe vdekjeve vjetore. Vendosja e këtyre vlerave
të mundësohet përmes konstruktorit ose përmes funksioneve, vendos_popullsi,
vendos_lindje dhe vendos_vdekje. Klasa të ketë edhe funksionet për leximin
dhe llogaritjen e shkallës së lindjeve dhe vdekjes.
10. Të shkruhet programi në të cilin krijohet klasa Afatizimet për
afatizimin e parave për periudha të ndryshme kohore. Interesi vjetor të
jetë i përshkallëzuar. P.sh afatizimi për 0-5 vite për shumat 0-1000€ të
jetë 3.2%; 5-8 vite për shumat 1000-5000€ të jetë 3.6% dhe për periudhat
mbi 8 vite dhe mbi 5000€ të jetë 4.2%. Të llogaritet interesi i shpërndarë
nëpër muaj dhe të shtypet gjendja për secilin klient.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
203
11. Të shkruhet programi në të cilën krijohet klasa koha e cila ruan orën,
minutat dhe sekondat. Të krijohen dy kohe të ndryshme dhe të gjendet sa
kohë ka kaluar prej kohës së parë deri të koha e dytë.
12. Të krijohet klasa libraria e cila përmban anëtarët titulli,
autori, botuesi, isbn, viti_botimit, cmimi dhe stoku. Të gjithë
këta janë anëtarë privat të klasës, kurse si anëtarë publik duhet
të jenë funksionet për vendosjen dhe marrjen e të dhënave për
secilin anëtarë. Emërtimi i funksioneve të klasës për vendosjen e
të dhënave të jetë sipas standardit v_emertimi (p.sh v_titullin),
kurse emërtimi për leximin/marrjen e vlerës së anëtarit të jetë
sipas standardit m_emertimi (p.sh m_titullin). Për numrat e ISBN të
krijohet një enumeration dhe të përmbajë numrin e juaj të indeksit
dhe katër numra të tjerë të indeksit. Në konstruktorin e klasës të
bëhet inicimi i anëtarëve të të dhënave (titulli, autori dhe
botuesi =" "; isbn me anëtarin e grupit që parqet numrin e juaj të
indeksit; viti_botimit=2008, cmimi=26 dhe stoku=50). Objekti i
klasës të jetë një vektor me madhësi të njëjtë sikurse muaji i
datëlindjes suaj + 1 (p.sh 17.02.2008; m=2+1=3). Mbushja e
anëtarëve me të dhëna të bëhet përmes një unaze duke përdorur
funksionin mbush() i cili si parametra formalë ka klasën libraria
dhe grupin isbn_numrat. Emri i librit të mbushet me një emër të
çfarëdoshëm; autori të jetë emri dhe mbiemri i juaj; botuesi të
jetë “Universiteti i Prishtinës”, ISBN të jetë numri i juaj i
indeksit i cili është anëtar i grupit; viti i botimit të jetë i
rastësishëm nga 2008 deri në 2013; çmimi i librit të jetë çmim i
rastësishëm nga 26€ deri në 55€; kurse vlera e stokut të zbritet
për nga një për secilin objekt. Shtypja e rezultateve të bëhet
përmes funksionit shtyp() dhe rezultati të jetë i formatuar si në
pamjen e mëposhtme.
9.6. Pointerët
1. Nëse z është variabël, cila shprehje e kthen adresën e variablës z?
a. *p
b. &p
c. *z
d. &z
2. Çka do të shtypet në ekran nëse ekzekutohet kodi i mëposhtëm?
int x, y;
int *p = &x;
int *q = &y;
*p = 35;
*q = 98;
*p = *q;
cout << x << " " << y << endl;
cout << *p << " " << *q << endl;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
204
3. Çka do të shtypet në ekran?
int x, y;
int *p = &x;
int *q = &y;
x = 35;
y = 46;
p = q;
*p = 78;
cout << x << " " << y << endl;
cout << *p << " " << *q << endl;
4. Të shkruhet programi në të cilin deklarohet vektori A me madhësi 5 dhe të
iniciohet me vlera (5, 10, 15, 20, 25).
a. Duke përdorur pointerin ptrA të shtypen vlerat e vektorit A dhe
adresat e anëtarëve të vektorit sipas rendit nga fillimi në fund.
b. Duke përdorur pointerin ptrA të shtypen vlerat e vektorit A dhe
adresat e anëtarëve të vektorit sipas rendit nga fundi në fillim
duke ia hequr secilit anëtarë edhe vlerën e indeksit.
5. Të shkruhet programi i cili notat e një studenti të dhëna përmes tastiere
i ruan në vektorin nota. Pasi të jenë ruajtur notat, duke shfrytëzuar
pointerin notaPtr të gjendet nota më e madhe, nota më e vogël dhe nota
mesatare.
6. Të shkruhet programi i cili vlerat e një vektori ku ruhen emrat e
studentëve i sorton duke shfrytëzuar pointerët.
9.7. Referencat
1. Të shkruhet programi në të cilin deklarohet një variabël v e tipit double
si dhe variabla referente vref. Vlera e variablës v të ndryshohet në
mënyrë të rastësishme dhe të shtypet vlera e variablës referente vref.
2. Të shkruhet programi në të cilin deklarohet funksioni çmimi_ri i cili ka
dy parametra formalë referentë. Në parametrin e parë të ruhet çmimi i
vjetër kurse në parametrin e dytë të jetë çmimi i ri. Zbritja të jetë e
rastësishme në me 5-25%.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
205
3. Të shkruhet programi përmes të cilit tregohet deklarimi i një fushe
tredimensionale A(m, n, k) dhe fusha referente B(m, n, k). Dy dimensione
të fushës të mbushen me vlera përmes fushës A, kurse një dimension të
mbushet përmes fushës referente B.
9.8. Fajllat
1. Të shkruhet programi i cili lexon në një fajll tekstual dhe i numëron
secilin karakter se sa herë paraqitet. Rezultati të shfaqet në ekran ose
të ruhen në një fajll tjetër.
2. Të shkruhet programi dhe të krijohet klasa teksti e cila përmban një
anëtar të tipit string për të mbajtur tekstin e një fajlli. Klasa të
përmbajë konstruktorin e nënkuptuar dhe konstruktorin i cili e ka si
parametër emrin e fajllit. Përmes këtij konstruktori të hapet fajlli
tekstual dhe përmbajtja e tij të ruhet në anëtarin e klasës. Përmbajtja e
tekstit të shtypet në ekran përmes funksionit permbajtja.
3. Të shkruhet programi i cili e lexon një fajll tekstual dhe paraqet
raportin e paraqitjes së secilës fjalë, pra sa herë është paraqitur secila
fjalë veç e veç.
4. Të shkruhet programi i cili ju mundëson që të mbani evidencën për pajisjet
që keni në punëtorinë tuaj. Të dhënat të ruhen në fajllin me qasje të
rastësishme puntoria.dat. Në evidencë duhet të përfshihen numri dhe emri i
pajisjes, vlera dhe viti i blerjes dhe koha e amortizimit. Programi të
ketë opsionet për shfaqjen e të gjitha pajisjeve, fshirjen e një pajisje,
përditësimin e të dhënave të pajisjes së caktuar si dhe regjistrimin e
pajisjeve të reja. Vlera aktuale e pajisjes të llogaritet në bazë të
vlerës së blerjes dhe kohës së amortizimit.
5. Të shkruhet programi i cili mundëson regjistrimin e numrave të telefonit
në një fajll me qasje të rastësishme adresari.dat. Formati i numrave të
telefoni të jetë ### ### ### p.sh 044 000 000. Të mundësohet gjetja e
numrit në bazë të emrit ose gjetja e emrit në bazë të numrit.
6. Të shkruhet programi i cili përmbajtjen e një fajlli e kopjon në një fajll
tjetër.
7. Të shkruhet programi i cili lexon përmbajtjen e një fajlli tekstual.
Përmbajtja e fajlliit është e përzier me shkronja dhe me numra. Të ndahen
numrat nga shkronjat dhe të ruhen në fajlla të veçantë.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
206
8. Të shkruhet programi i cili emrave të shkruar në një fajll tekstual ua
largon rreshtin e ri dhe të gjithë emrat të jenë në një rresh, por të
ndarë me pikëpresje (;).
9. Të shkruhet programi i cili përmbajtjen e një fajlli e ruan në një vektor
të tipit string. Numri i rreshtave të lexuar të përcaktohet gjatë
ekzekutimit.
10. Të shkruhet programi i cili lexon një fajll dhe të gjitha shkronjat i
kthen në shkronja të vogla dhe rezultatin e ruan në një fajll të ri.
11. Të shkruhet programi i cili lexon një fajll tekstual dhe i cili shfaq
në ekran nga 15 rreshta të tekstit. Pas shtypjes së tastit Enter të
shfaqen 15 rreshtat e ardhshëm.
12. Të shkruhet programi për menaxhimin e bankës. Për këtë të krijohet
klasa banka e cila si anëtarë privat ka numrin e llogarisë, mbajtësin e
llogarisë dhe depozitën fillestare e cila jepet/caktohet gjatë hapjes së
llogarisë së klientit. Funksionet e domosdoshme të implementuara brenda
klasës duhet të jenë:
 Funksioni për krijimin e llogarisë,
 Funksioni për deponim të parave
 Funksioni për tërheqje të parave
 Funksioni për shfaqjen e bilancit për klientin e caktuar
 Funksioni për mbyllje të llogarisë.
 Funksioni për afatizimin e parave.
 Funksion sipas dëshirës për një shërbim të caktuar bankar (Opsioni i
lirë)
Mund të implementohen edhe funksione tjera sipas nevojës, si brenda klasës
ashtu edhe jashtë klasës. Shënimet e klientit, duke shfrytëzuar objektin e
klasës të deklaruar si pointer të ruhen në fajllin me qasje direkte
(banka.bin).
13. Të shkruhet programi i cili të gjithë fajllat tekstual që gjenden në
një direktorium të caktuar i ruan në një fajll të vetëm. Përmbajtja e
secilit fajll të ndahet duke përdorur emrin e fajllit dhe përmbajtjen si
në vijim:
***********************
fajlli1
+++++++++++++++++++++++
. . .
përmbajtja e fajlli1
. . .
***********************
fajlli2

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
207
+++++++++++++++++++++++
. . .
përmbajtja e fajlli2
***********************
14. Të shkruhet programi i cili krijon një fajll binar në formatin si në
vijim: integer, char[15], char[15], byte[1024]. Në këtë fajll të ruhen
shënime të studenteve si numri, emri, mbiemri dhe foto. Gjatë futjes së
shënimeve në fajll, numri të plotësohet prej programit si numër rendor,
emri dhe mbiemri mbushen përmes tastiere, ndërsa foto lexohet prej fajllit
të ruajtur në një direktorium të caktuar p.sh c:\foto\. Emri i fotos është
i njëjtë me numrin rendor p.sh. 1.jpg, 2.jpg etj.
15. Të shkruhet programi i cili përmbajtjen e një fajlli tekstual e
enkripton duke përdorur kodin e Cezarit dhe përmbajtjen e enkriptuar e
ruan në fajll të veçantë.

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
208
Literatura
1. Agni Dika, Programimi i Orientuar në Objekte në C++; 2008, ISBN 9989-
866-25-2.
2. Bjarne Stroustrup, The C+ + Programming Language, Third Edition, AT&T
1997, ISBN 0201889544
3. Dale, Nell B.; Weems, Chip.; Headington, Mark R, Programming and
Problem Solving With C++ 3Rd Ed., Jones & Bartlett Publishers, Inc.
2002, ISBN13 9780763721039.
4. Dirk Henkemans, Mark Lee , C++ Programming for the Absolute Beginner,
Premier Press 2001, ISBN:1931841438
5. D.S. MALIK. C++ PROGRAMMING: PROGRAM DESIGN INCLUDING DATA STRUCTURES,
2011, ISBN-13: 978-0-538-79809-2
6. Edward Scheinerman, C++ for Mathematicians (An Introduction for
Students and Professionals), Chapman & Hall/CRC 2006, International
Standard Book Number-13: 978-0978-1-58488-584-9.
7. Francis Glassborow, You Can Program in C++ (A Programmer’s
Introduction), John Wiley & Sons Ltd 2006, ISBN-13: 978-0-470-01468-4.
8. Michael Goodrich, Roberto Tamassia, David Mount, Data Structures &
Algorithms, Second Edition, John Wiley & Sons, Inc 2011, ISBN-13 978-0-
470-38327-8
9. Ivor Horton's, Beginning Visual C++ 2012, John Wiley & Sons, Inc 2012,
ISBN: 978-1-118-36808-4
10. Joyce Farrell, Object-Oriented Programming Using C++, Fourth
Edition, Course Technology 2009, ISBN-13: 978-1-4239-0257-7
11. Paul Deitel, Harvey Dietel, C++ How to Program, 8/E, ISBN-10: 0-
13-266236-1
12. P.S. Deshpande and O.G. Kakde, C & Data Structures, Dreamtech
Press 2003, ISBN:1584503386
13. Robert Lafore, Object-Oriented Programming in C++, Fourth
Edition, Sams 2002, International Standard Book Number: 0-672-32308-7

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
209
14. Stephen Prata, C++ Primer Plus, Sixth edition, Addision -Wesley
2012, ISBN-13: 978-0-321-77640-2
15. Stephen Randy Davis, C++ For Dummies 5th Edition, Wiley
Publishing, Inc. 2004, ISBN: 0-7645-6852-3
16. Trevor Misfeldt, Gregory Bumgardner, Andrew Gray; The Elements of
C++Style, Cambridge university press 2004, isbn-13 978-0-521-89308-4
17. Tony Gaddis, Judy Walters, Godfrey Muganda; Starting Out with C++
Early Objects, Seventh Edition, Addison-Wesley 2010, ISBN 10: 0-13-
607774-9.
18. Walter Savitch, Absolute C++, Fifth Edition, Pearson 2013, ISBN-
10: 0-13-283071-X
19. Walter Savitch, Problem Solving with C++, Seventh Edition, 2009,
ISBN 13: 9780321531346
20. Vehbi Neziri, Përmbledhje detyrash në C++ (edicioni 1), Prishtinë
2012;

Vehbi Neziri & Ramadan Dervishi
Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++
210