Content uploaded by Vehbi Neziri
Author content
All content in this area was uploaded by Vehbi Neziri
Content may be subject to copyright.
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‰ program