Programimi I Orientuar Ne Objekte Ne C++

Fakulteti i Shkencave dhe i Teknologjive Bashkkohore
Universiteti i Europs Juglindore
Agni Dika
Programimi i Orientuar n Objekte n C++
2008
U lejua pr botim nga Komisioni pr botime pran Universitetit t Europs Juglindore n Tetov. Ndalohet ribotimi dhe kopjimi i librit, ose edhe i pjesve t tij, pa plqimin e autorit.
Parathnie
Libri q e keni n dor u dedikohet studentve t Fakultetit t Shkencave dhe Teknologjive Bashkkohore n Universitetin e Europs Juglindore n Tetov. Por, sigurisht, ai mund t shfrytzohet edhe nga student t universiteteve t tjera, ose edhe nga t gjith ata q dshirojn ta prvetsojn teknikn e programimit, e cila sht e orientuar n shfrytzimin e objekteve. Materiali q prfshihet n libr sht i nivelit t till q pr msimin e tij nevojitet nj dije bazike mbi principet e programimimit n gjuhn C++. Lexuesi mund komunikoj me autorin prmes adresave elektronike agnidika@yahoo.com dhe a.dika@see-university.edu.mk , ose edhe prmes lidhjes q ofrohet n faqen e internetit www.agnidika.net.
Hyrje
Programimi i zakonshm, i cili mbshtetet n shfrytzimin e komandave t gjuhs programuese C++, prfshir edhe thirrjen direkte t funksioneve t ndryshme, njihet si programimim i strukturuar (ang. structured programming). Gjat programimit t till, pjes t ndryshme funksionale bashkohen me qllim t krijimit t programeve komplete. Por, kjo mnyr e programimit nuk lejon fleksibilitet t madh gjat ndryshimit t programeve, gj q vjen n shprehje sidomos kur kemi t bjm me programe komplekse. Aktualisht, gjat shkruarjes s programeve shfrytzohen gjuh programuese t cilat e prmbajn disajnimin e orientuar n objekte (ang. objectoriented design, OOD). Te kto gjuh, pr zgjidhje t problemeve me kompjuter shfrytzohen strukturat dhe klasat, prkatsisht komponentet q quhen objekte. Prandaj, programimi prmes tyre njihet edhe si programim i orientuar n objekte (ang. object-oriented programming, OOP). Por, gjat prcaktimit t strukturave dhe klasave, si dhe operimit me objekte, prkatsisht me komponentet e tyre, prsri shfrytzohet programimi i strukturuar. Gjuha programuese C++, meq e prmban kt lloj programimi, sht gjuh e orientuar n objekte (ang. objectoriented language, OOL). Gjat programimit me objekte, strukturat dhe klasat brenda komponenteve t tyre i prfshijn t dhnat dhe funksionet q shfrytzohen pr manipulim me ato t dhna, t cilat mund t deklarohen si private dhe si publike. Kurse objektet prkatse karakterizohen me gjendjet e brendshme (ang. internal state) dhe gjendjet e jashtme (ang. external state) t tyre. Gjendjet e brendshme prcaktohen nga antart privat t objekteve dhe nuk mund t ndryshohen nga jasht. Kurse, n prcaktimin e gjendjeve t jashtme t objekteve shfrytzohen antart publik t tyre. Programi i orientuar n objekte paraqet nj form natyrore t veprimeve q ndrmerren gjat zgjidhjes s problemeve t ndryshme me kompjuter. Shfrytzuesi i nj objekti nuk ka nevoj ta dij prbrjen e brendshme t tij. Kjo i ngjan, p.sh., shfrytzimit t ors, ose ngarjes s veturs, pa i ditur pjest prbrse dhe mnyrn e funksionimit t tyre. N kapitullin e par t librit lexuesi do t njihet me grupimin e t dhnave prmes numrimit (ang. enumeration). Pastaj, kapitulli i dyt dhe i tret
2 Programimi i orientuar n objekte merret me strukturat dhe klasat, si dhe me objektet q deklarohen prmes tyre. N kapitujt vijues jepen njohuri t nevojshme pr pun me pointer (kapitulli i katrt) dhe referencat (kapitulli i pest). Prmes tyre lehtsohet operimi me t dhna t zakonshme, veanrisht gjat shfrytzimit t funksioneve, si dhe operimi me objekte. N kapitullin e fundit, n mnyr t detajizuar shpjegohet shfrytzimi i fajllave (ang. file), prkatsisht hapja e fajllave, mbushja e tyre me t dhna, leximi i t dhnave nga fajllat dhe mbyllja e fajllave, krejt kjo prmes shembujve t ndryshm.
Prmbajtja
Hyrje 1. Numrimet Prcaktimi i grupit 4 Shfrytzimi i grupit 6 Degzimi prmes vlerave t numruara 7 Degzimi me komandn if 7 Degzimi me komandn switch 9 Disa variabla t numruara t tipit t njjt 12 Prcaktimi dhe deklarimi njkohsisht 13 Shoqrimi direkt i vlerave 16 Operimi me variabla t numruara 19 Barazimi i variablave t numruara 20 Llogaritja me vlera t numruara 21 Variablat e numruara n unaza 23 Leximi i t dhnave t numruara 27 Definimi i disa grupeve njkohsisht 28 T dhnat e numruara n nnprograme 31 2. Strukturat Definimi i strukturave t zakonshme 34 Deklarimi i variablave t tipit t strukturs 36 Qasja te komponentet e strukturs 37 Deklarimi direkt i variabls s strukturs 39 Inicializimi direkt i variablave 44 Llogaritje me variablat e strukturs 46 Ruajtja e rezultateve n struktur 49 Disa variabla t nj strukture 51 Deklarimi pasi sht definuar struktura 51 Deklarimi gjat definimit t strukturs 55 Prdorimi i operacionit t shoqrimit 60 Prdorimi i operatorve relacional 62 Disa struktura njkohsisht 65
vi Programimi i orientuar n objekte

Strukturat e ndrthurura 70 Strukturat si parametra t funksioneve 73 Funksione me parametra t przier 78 Thirrja e prsritur e funksionit 82 Disa struktura si parametra t funksioneve 85 Disa nnprograme njkohsisht 88 Funksionet n komponentet e strukturave 90 Funksionet pa parametra formal 91 Definimi brenda strukturs 91 Definimi jasht strukturs 100 Funksionet me parametra formal 104 Definimi brenda strukturs 104 Definimi jasht strukturs 108 Shfrytzimi n struktur i funksioneve t tjera 110 Disa funksione brenda strukturs 115 Disa struktura brenda funksioneve 119 Fushat n struktura 124 Fushat e strukturave 128 3. Klasat Definimi i klasave t zakonshme 134 Deklarimi i objekteve 136 Qasja te komponentet e klass 137 Forma e prgjithshme e klasave 139 Definimi i funksioneve jasht klass 143 Forma t tjera t inicializimit t variablave 145 Inicializimi prmes leximit 145 Inicializimi gjat deklarimit t objekteve 147 Shfrytzimi i vlerave t variablave private 149 Funksionet pa parametra formal 149 Funksionet me parametra referent 151 Llogaritjet me variablat e klass 153 Llogaritjet n program 153 Llogaritjet prmes funksioneve t klass 157 Rezultatet te variablat e programit 157 Rezultatet te variablat e klass 161 Shfrytzimi i funksioneve brenda klass 164 Funksionet n komponentet publike 164 Funksionet n komponentet private 168 Konstruktort 172 Konstruktort pa parametra formal 172 Konstruktort me parametra formal 176 Llogaritjet brenda konstruktorve 179 Disa konstruktor njkohsisht 182 Thirrja n baz t numrit t parametrave 183
Prmbajtja vii
Thirrja n baz t tipit t parametrave 185 Destruktort 188 Trashgimia 191 Definimi i funksioneve jasht klasave 195 Shfrytzimi i antarve t mbrojtur 196 Shfrytzimi i antarve gjat trashgimis 198 Ridefinimi i funksioneve t klass baz 199 Trashgimia e shumfisht 202 Operatori i shoqrimit tek objektet 204 Krahasimi i variablave t klass 206 Fushat brenda klasave 212 Fushat e objekteve 214 Dukshmria e klasave dhe e objekteve 217 4. Pointert Deklarimi i pointerve 218 Adresat e variablave 220 Vlera n adresn e variabls 222 Shoqrimi i vlerave 224 Shoqrimi i vlerave t konstanteve 224 Shoqrimi i vlerave t variablave 225 Operatort inverz 227 Llogaritjet prmes pointerve 231 Operimi me vlerat e pointerve 239 Rritja dhe zvoglimi i vlerave 239 Shoqrimi dhe krahasimi i vlerave 241 Pointert gjat operimit me fusha 242 Operimi me antart e vektorve 242 Pointert n antart e vektorve 242 Pointeri n antarin e par t vektorit 244 Indekset si pointer 248 Pointert pa i deklaruar 251 Operimi me antar t matricave 254 Shtypja e antarve t matricave 254 Gjetja e antarit t caktuar n matric 258 Formimi i vektorit nga antart e matrics 260 Shuma e antarve t matrics 262 Pointert n stringje 264 Fusha pointersh 265 Pointert si parametra t funksioneve 267 Mundsit themelore 268 Mundsi t tjera 273 Vektort si pointer 276 Pointert n funksione 279 Fusha pointersh n funksione 282
viii Programimi i orientuar n objekte

Pointert n struktura 286 Pointert n objekte 289 Qasja te variablat e klass 289 Qasja te funksionet e klasave 291 5. Referencat Referencat e zakonshme 296 Konstantet referente 300 Parametrat formal referent 302 Parametrat referent si rezultate 305 Fushat referente 306 Vektort referent 306 Matricat referente 307 Kufizime pr variablat referente 309 Parametrat referent brenda strukturave 309 Variablat referente brenda klasave 311 Objektet referente 312 6. Fajllat Fajllat me qasje sekuenciale 317 Shkruarja n fajll 318 Memoria ndrmjetsuese 320 Leximi nga fajlli 321 Kontrollimi i hapjes s fajllave 323 Deklarimi i objektit para hapjes 325 Qasja te fajllat n unaz 328 Shkruarja n unaz 328 Shfrytzimi i manipulatorve 329 Leximi n unaz 331 Flamujt e statusit 334 Shkruarja dhe leximi n nj program 337 Shfrytzimi i dy objekteve t veanta 337 Shfrytzimi i nj objekti t vetm 339 Tekstet n fajlla 341 Tekstet dhe numrat n fajlla 343 Shkruarja dhe leximi i karaktereve 347 Forma t tjera t unazave pr lexim 350 Shfrytzimi i pointerve 351 Leximi i rreshtave 352 Leximi i komplet rreshtave 352 Leximi deri n simbolin e caktuar 353 Mode t hapjes s fajllave 356 Kombinimet e modeve t hapjes 356 Hapja e fajllave n modin binar 359
Prmbajtja ix
Pozita n fajll 360 Leximi i pozits aktuale n fajll 363 Qasja dhe lvizja e lir brenda fajllave 365 Qasja relative n fajll 366 Fajllat me qasje direkte 372 Shkruarja n fajlla 373 Leximi nga fajllat 374 Vlerat e disa variablave n fajlla 376 Vlerat e fushave n fajlla 377 Vlerat e vektorve 378 Vlerat e matricave 381 Vlerat e llogaritura n fajlla 382 Tekstet n fajlla 384 Tekstet dhe vlerat numerike n fajlla 386 Qasja direkte n t dhnat e fajllave 387 Shfrytzimi i t dhnave nga fajllat 389 Objektet n fajlla 391 Objektet te fajllat me qasje sekuenciale 391 Objektet te fajllat me qasje direkte 394 Prmes variablave t komponenteve me t dhna 394 Prmes blloqeve me t dhna 396 Objektet me funksione 399 Disa fajlla t hapur njkohsisht 404 Literatura
1
Numrimet
Prcaktimi i grupit 4 Shfrytzimi i grupit 6 Degzimi prmes vlerave t numruara 7 Disa variabla t numruara t tipit t njjt 12 Prcaktimi dhe deklarimi njkohsisht 13 Shoqrimi direkt i vlerave 16 Operimi me variabla t numruara 19 Leximi i t dhnave t numruara 27 Definimi i disa grupeve njkohsisht 28 T dhnat e numruara n nnprograme 31
4 Programimi i orientuar n objekte
N gjuhn programuese C++ t dhnat e caktuara mund t grupohen, si thuhet prmes numrimit (ang. enumeration) t tyre. Kshtu, p.sh., mund t grupohen ditt e javs, muajt e vitit, ngjyrat, vlerat logjike etj. N kt mnyr krijohen tipe t reja t t dhnave, t cilat njihen si tipe t numruara (ang. enumerated type). Pastaj, kto t dhna mund t shfrytzohen pr deklarimin e variablave t tipeve prkatse, me qllim t shfrytzimit t tyre gjat shkruarjes s programeve t ndryshme.
Prcaktimi i grupit
Grupi i t dhnave prcaktohet duke e shfrytzuar komandn enum, e cila n form t prgjithshme shkruhet:
enum e { a0, a1, ... an };
ku jan:
e - emri i grupit. a0, a1, , an - antart e grupit.
Antart e grupit quhen edhe numrues (ang. enumerator) dhe n fakt paraqesin konstante t emruara. Gjat grupimit, do antari t grupit kompjuteri automatikisht i shoqron nj vler t nnkuptuar (ang. default value) n form t numrit, duke filluar me vlern 0, e cila pastaj pr do antar vijues rritet pr 1. Emri i grupit (e) si dhe emrat e antarve q prfshihen n grup (a0, a1, ..., an) formohen n baz t rregullave q vlejn pr identifikatort. Shembull Programi enum1a, n t cilin definohet grupi java, i prbr prej ditve t javs.
Numrimet 5
// Programi enum1a #include <iostream> using namespace std; enum java { hene, marte, merkure, enjte, premte, shtune, diel }; int main() { } Me komandn enum ktu definohet grupi java, n t cilin prfshihen
identifikator q kan t bjn me ditt e javs. Gjat prcaktimit t emrave t ditve t javs, nuk jan shfrytzuar shkronjat e alfabetit shqip, meq rregullat pr krijimin e identifikatorve e ndalojn. do identifikatori q prfshihet n grup, ashtu si u tha edhe m sipr, kompjuteri i shoqron nj vler numerike. Kshtu, identifikatorit hene ia shoqron vlern 0, identifikatorit marte - vlern 1 dhe kshtu me radh. Pr kt arsye, antart e grupit paraqesin konstante, dhe, kur flitet pr grupime prmes komands enum, duhet nnkuptuar grupimin e konstanteve. Ktu, pjesa e programit sht e zbrazt dhe grupi i prcaktuar nuk sht prdorur pr asgj. Grupi mund t prcaktohet duke e vendosur edhe brenda programit. Gjat ksaj, programi i dhn m sipr do t duket si n vijim.
// Programi enum1b #include <iostream> using namespace std; int main() { enum java { hene, marte, merkure, enjte, premte, shtune, diel }; }
6 Programimi i orientuar n objekte N kt rast, grupi ka karakter lokal dhe mund t shfrytzohet vetm brenda programit, por jo edhe jasht tij.
Shfrytzimi i grupit
Pasi t jet prcaktuar grupi, prmes emrit t tij mund t deklarohen variabla t tipit t grupit. Forma e deklarimit t variablave sht plotsisht e njjt me deklarimin e variablave t tipeve standarde dhe n rast t prgjithshm duket:
e v;
ku jan:
e - emri i grupit. v - variabla q deklarohet e tipit t grupit t prcaktuar.
Shembull
Programi enum2, n t cilin definohet dhe shfrytzohet grupi java, i prbr prej ditve t javs.
// Programi enum2 #include <iostream> using namespace std; enum java { hene, marte, merkure, enjte, premte, shtune, diel }; int main() { java dita; dita=marte; cout << "\nDits s mart i shoqrohet numri: " << dita << "\n\n"; return 0; }
Numrimet 7 N program, prmes deklarimit:

java dita;
variabla dita deklarohet e tipit java dhe n t mund t ruhen t dhnat e prfshira brenda kllapave t grupit n fjal. Nse ekzekutohet programi i dhn, meq prmes komands:
dita=marte;
variabls dita t tipit java i sht shoqruar antari i dyt n grup, t cilit i korrespondon vlera numerike 1, rezultati n ekran do t duket si n Fig.2.1. Fig.2.1 Pamja e ekranit pas ekzekutimit t programit
enum2
Variabls dita mund t'i shoqrohen vetm antart e grupit. Kshtu, pavarsisht nga vlerat q u prkasin antarve t grupit, shoqrimi direkt i vlerave nuk lejohet, prkatsisht kompjuteri do t lajmroj gabim, nse p.sh., n program shkruhet shprehja:
dita=1;
Antart e grupit, gjat prcaktimit t tij, mund t shkruhen n disa rreshta (ashtu si u dha m sipr), ose edhe n vetm nj rresht, p.sh.:
enum java {hene,marte,merkure,enjte,premte,shtune,diel};
Degzimi prmes vlerave t numruara

Vlerat e numruara mund t shfrytzohen pr realizimin e degzimeve t ndryshme edhe at duke e prdorur komandn if, ose komandn switch.
Degzimi me komandn if
Variablat, t cilat deklarohen si variabla t tipit t numruar n kombinim me operatort relacional, mund t shfrytzohen pr realizimin e degzimeve t ndryshme prmes komands if.
8 Programimi i orientuar n objekte Shembull Programi enum3, n t cilin tregohet degzimi prmes komands if, duke e krahasuar variabln e numruar koha.
// Programi enum3 #include <iostream> using namespace std; enum rezultati { Po, Jo }; int main() { rezultati koha; koha=Po; cout << "\nRezultati sht "; if (koha==Po) cout << "pozitiv"; else cout << "negativ"; cout << "\n\n"; return 0; }
N program, fillimisht sht prcaktuar grupi rezultati, me dy antart e tij Po dhe Jo. Pastaj, pas deklarimit t variabls koha t tipit rezultati, me shprehjen:
koha=Po;
variabls i shoqrohet vlera Po e grupit. N fund, prmes komands if, kontrollohet se a sht barazi vlera e variabls koha me vlern Po dhe varsisht nga raporti i tyre shtypet fjala pozitiv ose negativ. N kt rast, meq variabls koha i sht ndar vlera Po, n ekran do t shtypet fjalia:
Rezultati sht pozitiv
ku me ngjyr t zez sht theksuar fjala q shtypet, duke kaluar n degn e par t komands if.
Numrimet 9
Degzimi me komandn switch

Antart e grupeve zakonisht shfrytzohen pr realizimin e degzimeve t shumfishta prmes komands switch. Shembull Programi enum4a, prmes s cilit tregohet shfrytzimi i komands switch pr degzim t shumfisht n baz t vlerave t antarve t grupit java.
// Programi enum4a #include <iostream> using namespace std; enum java { hene, marte, merkure, enjte, premte, shtune, diel }; int main() { java dita; dita=marte; cout << "\nDita q u zgjodh sht dita e "; switch (dita) { case hene: cout << "hn";break; case marte: cout << "mart";break; case merkure: cout << "mrkur";break; case enjte: cout << "enjte";break; case premte: cout << "premte";break; case shtune: cout << "shtun";break; case diel: cout << "diel";break; } cout << "\n\n"; return 0; }
10 Programimi i orientuar n objekte Ktu, me komandn enum para programit, definohet grupi java. Pastaj, duke e shfrytzuar komandn switch, realizohet degzimi n baz t vlerave q u shoqrohen antarve q prfshihen n grup. Kshtu, meq prmes shoqrimit:
dita=marte;
variabls dita t tipit java i shoqrohet numri rendor 1, i cili i prket dits s mart, me komandn pr degzim zgjedhet dega e dyt:
case marte: cout << "mart";break;
me ka pjess s fjalis:
Dita q u zgjodh sht dita e
e cila shtypet para komands switch, i shtohet edhe fjala mart, pr ta fituar formn definitive t fjalis:
Dita q u zgjodh sht dita e mart
gj q shihet edhe n rezultatin q me at rast shtypet n ekran (shih Fig.2.2). Fig.2.2 Pamja e ekranit pas ekzekutimit t programit enum4a Rezultati do t jet i njjt nse programi enum4a shkruhet ashtu si sht dhn n vijim, tek i cili shfrytzohet variabla t e tipit string.
// Programi enum4b #include <iostream> #include <string> using namespace std; enum java { hene, marte, merkure, enjte, premte, shtune, diel }; int main() {
Numrimet 11
java dita; string t; dita=marte; switch (dita) { case hene: case marte: case merkure: case enjte: case premte: case shtune: case diel: } cout << "\nDita q << t << "\n\n"; return 0; }
t= t= t= t= t= t= t=
"hn";break; "mart";break; "mrkur"; break; "enjte";break; "premte";break; "shtun";break; "diel";break;
u zgjodh sht dita e "
N program, fillimisht, sht deklaruar variabla t e tipit string, n t ciln ruhen emrat e ditve t javs. Meq deklarimi string nuk sht standard, pr ta shfrytzuar kt deklarim n ballinn e programit sht vendosur komanda paraprocesorike #include <string>, sepse n modulin string sht prcaktuar deklarimi n fjal. Edhe n kt rast, pas ekzekutimit t programit t dhn, rezultati n ekran do t duket si ai q u dha n Fig.2.2. Rezultati i programit t dhn m sipr nuk ndryshon nse degt e veanta t komands switch shkruhen edhe kshtu:
switch (dita) { case 0: t= "hn";break; case 1: t= "mart";break; case 2: t= "mrkur";break; case 3: t= "enjte";break; case 4: t= "premte";break; case 5: t= "shtun";break; case 6: t= "diel";break; }
N kt rast, n vend t emrave t ditve t javs, meq kemi t bjm me konstante, jan shfrytzuar vlerat e nnkuptuara t tyre.
Disa variabla t numruara t tipit t njjt

Sikurse te variablat e tipeve standarde, brenda nj programi mund t deklarohen edhe disa variabla t numrurara t tipit t njjt. Gjat ksaj, komanda prkatse pr deklarim n form t prgjithshme do t duket:
e v1,v2,...,vn;
ku jan:
e - emri i grupit. v1,v2,...,vn - variablat q deklarohen t tipit t grupit t prcaktuar.
Shembull
Programi enum5, prmes s cilit tregohet deklarimi i dy variablave t numruara t tipit java.
// Programi enum5 #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 << << << << << return 0; } "\nDitt e puns fillojn me numrin: " punuese "\n\nDitt e pushimit fillojn me numrin: " pushuese "\n\n";
Numrimet 13 Ktu, prmes komandave:

java punuese; java pushuese;
variablat punuese dhe pushuese jan deklaruar si variabla t numruara t tipit java. N kto variabla mund t ruhen t gjitha vlerat e mundshme q prfshihen n grupin n fjal, pavarsisht se pr ciln dit t javs kemi t bjm. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.2.3. Fig.2.3 Pamja e ekranit pas ekzekutimit t programit
enum5
Nnkuptohet se edhe variablat e numruara mund t deklarohen duke e shfrytzuar vetm nj komand:
java punuese,pushuese;
plotsisht njlloj si deklarohen variablat standarde.
Prcaktimi dhe deklarimi njkohsisht

Gjat prcaktimit t grupit me t dhna t numruara, njkohsisht mund t bhet edhe deklarimi i variabls prkatse. Pr kt qllim, komanda enum shkruhet:
enum e { a0, a1, ... an } v;
ku jan:

e - emri i grupit. a0, a1, , an - antart e grupit. v - variabla e tipit t grupit q prcaktohet.
Shembull
Programi enum6, prmes s cilit tregohet prcaktimi i grupit viti, si dhe njkohsisht deklarohet variabla stina e tipit q definohet.
// Programi enum6 #include <iostream> using namespace std; enum viti { pranvera, vera, vjeshta, dimri } stina; int main() { stina=vera; if (stina==pranvera) cout << "\nStina e pranvers"; else if (stina==vera) cout << "\nStina e vers"; else if (stina==vjeshta) cout << "\nStina e vjeshts"; else cout << "\nStina e dimrit"; cout << "\n\n"; return 0; } Si shihet m sipr, para programit sht prcaktuar grupi viti, duke e shnuar n fund edhe variabln stina. N kt mnyr kompjuteri njoftohet se variabla stina sht deklaruar variabl e tipit viti dhe si e till shfrytzohet n program. Nse ekzekutohet programi n fjal, meq n fillim t tij paraqitet shprehja:
Numrimet 15
stina=vera; rezultati q fitohet n ekran do t duket si n Fig.2.4.
Fig.2.4 Pamja e ekranit pas ekzekutimit t programit

enum6
Gjat prcaktimit t grupit, njkohsisht mund t deklarohen edhe m shum variabla t atij tipit, duke e shkruar komandn enum n form t prgjithshme:
enum e { a0, a1, ... an } v1,v2,...,vm;
ku jan:
e - emri i grupit. a0, a1, , an - antart e grupit. v1,v2,...,vm - variablat e tipit t grupit q prcaktohet.
Shembull
Programi enum7, prmes s cilit tregohet prcaktimi i grupit viti, si dhe njkohsisht deklarohen variablat stina dhe koha t atij tipi.
// Programi enum7 #include <iostream> using namespace std; enum viti { pranvera, vera, vjeshta,

dimri } stina,koha; int main() { stina=vera; koha=dimri; if (stina==koha) cout << "\nPerioda e njjt"; else cout << "\nPerioda ndryshon"; cout << "\n\n"; return 0; }
Ktu, menjher pas komands paraprocesorike sht prcaktuar grupi

viti, si dhe njkohsisht jan deklaruar t tipit viti variablat stina dhe koha. Pastaj, n fillim t tij jan marr vlerat: stina=vera; koha=dimri;
Pas ekzekutimit t komands if, pr vlerat e marra t variablave stina dhe koha, rezultati q shtypet n ekran do t duket si n Fig.2.5. Fig.2.5 Pamja e ekranit pas ekzekutimit t programit
enum7
Shoqrimi direkt i vlerave

Vlerat e nnkuptuara t antarve t grupit mund edhe t ndryshohen, duke u shoqruar direkt vlerat numerike. Ky shoqrim n form t prgjithshme duket:
Numrimet 17
enum e { a0=k0, a1=k1, ... an=kn };
ku jan:
e - emri i grupit. a0, a1, , an - antart e grupit. k1,k2,...,kn - konstantet q u shoqrohen antarve t grupit.
Gjat ktij shoqrimi vlerat e konstanteve zgjedhen sipas dshirs, por mund t merren edhe t barabarta me vlerat e nnkuptuara t tyre. Shembull Programi enum9, prmes s cilit tregohet krahasimi i vlerave t antarve t grupit.
// Programi enum9 #include <iostream> using namespace std; enum nota { pese=5, gjashte=6, shtate=7, tete=8, nente=9, dhjete=10 }; int main() { nota programim,vizatim; programim=tete; vizatim=nente; cout << "\nNota n programim sht " << programim << "\n"; cout << "Nota n vizatim sht " << vizatim << "\n";
if (programim < vizatim) cout << "\nNota n vizatim sht m e madhe"; else cout << "\nNota n vizatim s'sht m e madhe"; cout << "\n\n"; return 0; }
N program fillimisht sht deklaruar grupi nota, n t cilin jan prfshir emrat e notave t mundshme dhe vlerat e tyre. Pastaj, prmes komandave:
nota programim,vizatim; programim=tete; vizatim=nente;
s pari deklarohen variablat programim e vizatim t tipit nota, dhe pastaj atyre u shoqrohen vlerat tete dhe nente. N fund, pasi shtypen vlerat e variablave n fjal, prmes komands if ato krahasohen dhe, duke e pasur parasysh raportin e tyre, shtypet rezultati i cili shihet n Fig.2.9.
Fig.2.9 Pamja e ekranit pas ekzekutimit t programit enum9 Disa antar t grupit mund t ken edhe vlera t njjta. Shembull Programi enum8, prmes s cilit tregohet shoqrimi direkt i vlerave t antarve t grupit java, n t cilin prfshihen ditt e javs.
// Programi enum8 #include <iostream> #include <string> using namespace std; enum java { hene=1, marte=1,
Numrimet 19
merkure=1, enjte=1, premte=1, shtune=2, diel=2 }; int main() { java dita; string t; dita=shtune; switch (dita) { case 1: t= "dit pune";break; case 2: t= "dit pushimi";break; } cout << "\nDita q u zgjodh sht " << t << "\n\n"; return 0; }
N program, gjat deklarimit t grupit, antarve q kan t bjn me ditt e javs mes t hns dhe t premtes u jan shoqruar vlerat 1, kurse dy antarve t fundit - vlerat 2. Pastaj, meq prmes barazimit:
dita=shtune;
sht zgjedhur antari t cilit n grup i sht shoqruar vlera 2, rezultati q shtypet n ekran do t duket si n Fig.2.6. Fig.2.6 Pamja e ekranit pas ekzekutimit t programit enum8 Vlerat t cilat u shoqrohen antarve t grupit mund t jen edhe t ndryshme.
Operimi me variabla t numruara

Variabla e numruar mund t'i shoqrohet nj variable tjetr t numruar, prmes operatorit t barazimit. Gjithashtu, vlerat e variablave t numruara mund t shfrytzohen gjat llogaritjeve t ndryshme, ose t merren edhe si variabla t unazave.
Barazimi i variablave t numruara

Mes dy variablave t numruara, t cilat jan t tipit t njjt, mund t vendoset shenja e barazimit, n kt mnyr:
v1=v2;
ku jan:
v1, v2 - variabla t tipit t njjt.
Si rezultat i ktij barazimi, variabls v1 do t'i shoqrohet vlera e variabls v2, por me kusht q t dy variablat t jen t tipit (t grupit) t njjt. Shembull Programi enum10, prmes s cilit tregohet barazimi i variablave programim dhe vizatim, t cilat jan deklaruar si variabla t tipit nota.
// Programi enum10 #include <iostream> using namespace std; enum nota { pese, gjashte, shtate, tete, nente, dhjete }; int main() { nota programim,vizatim; programim=tete; vizatim=programim; cout << "\nNota n vizatim sht "; switch(vizatim) { case pese: case gjashte: case shtate: case tete: case nente: case dhjete: }
cout cout cout cout cout cout
<< << << << << <<
"pes";break; "gjasht";break; "shtat";break; "tet";break; "nnt";break; "dhjet";break;
Numrimet 21
cout << "\n\n"; return 0; }
N fillim t programit sht prcaktuar variabla e numruar nota, n t ciln prfshihen emrat e notave prej pes deri n dhjet. Pastaj, prmes komands:
nota programim,vizatim;
jan deklaruar variablat programim dhe vizatim t tipit nota. Me shprehjen:

programim=tete;
variabls programim i sht shoqruar vlera tete. Kurse, prmes barazimit:

vizatim=programim;
vlera e variabls programim i shoqrohet edhe variabls vizatim. Pas ekzekutimit t programit n fjal, rezultati n ekran do t duket si n Fig.2.7. Fig.2.7 Pamja e ekranit pas ekzekutimit t programit
enum10
Llogaritja me vlera t numruara

Variablat e numruara nuk mund t shfrytzohen n shprehje t ndryshme pr llogaritje. Por, duke e shfrytzuar operatorin pr ndrrim eksplicit t tipit (ang. explicit type conversion operator) static_cast, mund t rriten ose t zvoglohen vlerat e t dhnave t tipit t numruar. Shembull Programi enum11, prmes s cilit tregohet rritja pr 2 e vlers s variabls lule, e cila sht deklaruar si variabl e tipit t numruar ngjyra.

// Programi enum11 #include <iostream> #include <string> using namespace std; enum ngjyra { kuqe, kalter, bardhe, gjelber, verdhe, }; int main() { ngjyra lule; string g; lule=kalter; cout << "\nVlera fillestare: << lule << " Ngjyr e kaltr" << "\n";
"
lule=static_cast<ngjyra>(lule+2); cout << "\nVlera e llogaritur: " << lule; switch (lule) { case 0: g="Ngjyr e kuqe";break; case 1: g= "Ngjyr e kaltr";break; case 2: g="Ngjyr e bardh";break; case 3: g="Ngjyr e gjelbr";break; case 4: g="Ngjyr e verdh";break; } cout << " " << g << "\n\n"; return 0; }
N program, fillimisht sht prcaktuar grupi i numruar ngjyra, n t cilin prfshihen variabla pr disa ngjyra. Pastaj, sht deklaruar variabla lule e tipit ngjyra.
Numrimet 23
Prmes shprehjes:
lule=kalter;
sht prcaktuar vlera fillestare e variabls lule. N vijim, me shprehjen:

lule=static_cast<ngjyra>(lule+2);
kjo vler sht rritur pr 2, gj q shihet edhe nga rezultati i shtypjes s vlers fillestare dhe i vlers s rritur (shih. Fig.2.8). Fig.2.8 Pamja e ekranit pas ekzekutimit t programit
enum11
Operatori static_cast ndryshe quhet operator i kasts (ang. cast operator), ose edhe operatori pr kastim t tipit (ang.type casting operator).
Variablat e numruara n unaza

Meq mbi variablat e numruara nuk lejohet zbatimi direkt i asnj operacioni aritmetikor, si dhe i operacioneve pr rritjen ose zvoglimin e tyre, pr t'i shfrytzuar si variabla t unazave, rritja ose zvoglimi i vlerave t tyre bhet me ndrmjetsimin e operatorit pr ndrrim eksplicit t tipit (ang. explicit type conversion operator) static_cast. Shembull Programi enum12, prmes s cilit shtypen 5 ngjyrat e prfshira n grupin ngjyra.
// Programi enum12 #include <iostream> #include <string> using namespace std; enum ngjyra { kuqe, kalter, bardhe, gjelber,

verdhe, }; int main() { ngjyra lule; string g;
for (lule=kuqe;lule<=verdhe;lule=static_cast<ngjyra>(lule+1))
{ switch (lule) { case 0: case 1: case 2: case 3: case 4: } cout << << << << << } cout << return 0; } g="Ngjyr e kuqe";break; g= "Ngjyr e kaltr";break; g="Ngjyr e bardh";break; g="Ngjyr e gjelbr";break; g="Ngjyr e verdh";break;
"\nVlera: " lule " " g "\n"; "\n";
N program, brenda komands for sht shfrytzuar shprehja:

lule=static_cast<ngjyra>(lule+1)
me t ciln rritet pr 1 vlera e variabls lule. Nse ekzekutohet programi i dhn, rezultati q fitohet n ekran do t duket si n Fig.2.10.

enum12
Numrimet 25
Por, variablat e numruara mund t shfrytzohen gjat prcaktimit t vlerave q marrin pjes n llogaritje t ndryshme. Shembull Programi enum13, prmes s cilit tregohet llogaritja e fitimit javor, nse numri i orve t puns n 5 ditt e puns s javs ruhet n vektorin h, kurse vlera e ors s puns v kompjuterit i jepet si vler hyrse.
// Programi enum13 #include <iostream> #include <iomanip> #include <string> using namespace std; enum java { hene, marte, merkure, enjte, premte }; int main() { double v,z,h[5]={6.5,8,7.4,2,9.6}; char t[]="--------------------------"; string d; java dita; cout << "\nVlera e ors: "; cin >> v; cout << "\n Dita Or Vlera\n" << t; z=0;
for (dita=hene;dita<=premte;dita=static_cast<java>(dita+1))
{ switch (dita) { case hene:d="e hn";break; case marte:d="e mart";break; case merkure:d="e mrkur";break; case enjte:d="e enjte";break; case premte:d="e premte";break; } cout << "\n" << setw(10)

<< d << fixed << setprecision(2) << setw(7) << h[dita] << setw(8) << v*h[dita]; z=z+v*h[dita]; } cout << "\n" << t << "\n Totale: << fixed << setprecision(2) << z << "\n\n"; return 0; }
"
Ktu, fillimisht sht prcaktuar grupi java n t cilin prfshihen pes ditt e puns n jav. Pastaj, gjat deklarimit t variablave, pr ort e puns n ditt e veanta, vlerat prkatse jan shnuar te vektori h. Vlera e ors v kompjuterit i jepet si vler hyrse prmes tastiers. Pas ksaj, prmes unazs e cila sht realizuar duke i shfrytzuar vlerat e numruara, sht shtypur tabela e orve t puns gjat ditve t veanta dhe vlerat e tyre. N fund sht shtypur vlera totale, e cila sht llogaritur si shum e vlerave ditore, duke e shfrytzuar shprehjen:
z=z+v*h[dita];
Rezultati q me kt rast shtypet n ekran, pr vlern hyrse v=10.5, do t duket si n Fig.2.11.

enum13
Numrimet 27
Leximi i t dhnave t numruara

Leximi direkt i t dhnave t numruara nuk sht i mundshm. Por, indirekt mund t lexohen vlerat n baz t t cilave pastaj, prmes programit, variablave t numruara u ndahen vlerat prkatse. Shembull Programi enum14, prmes s cilit tregohet procedura e leximit indirekt t vlerave t antarve t grupit.
// Programi enum14 #include <iostream> using namespace std; enum logjike {Po,Jo,Gabim}; int main() { logjike alfa; char h; cout << "\nVlera hyrse P pr Po dhe J pr Jo: "; cin >> h; cout << "\nPrgjigjja sht "; switch (h) { case 'P': alfa=Po; cout << "Po";break; case 'J': alfa=Jo; cout << "Jo";break; default: alfa=Gabim; cout << "gabim";break; } cout << "\nVlera e variabls alfa: " << alfa << "\n\n"; }
28 Programimi i orientuar n objekte N program, fillimisht sht prcaktuar grupi:

enum logjike {Po,Jo,Gabim};
n t cilin prfshihen 3 variabla. Pastaj, deklarohet variabla alfa e tipit

logjike.
Meq leximi direkt i vlerave t variablave q prfshihen n grup nuk lejohet, me qllim t realizimit t leximit sht shfrytzuar variabla ndihmse h, n t ciln mund t lexohet nj simbol. Kshtu, nse pas ekzekutimit t programit, prmes tastiers si vler hyrse shkruhet shkronja P, rezultati n ekran do t duket si n Fig.2.12.

enum14
Ktu, meq variabla Po n grup sht vendosur n pozitn e par, vlera e nnkuptuar e saj sht 0, prandaj edhe shtypet kjo vler.
Definimi i disa grupeve njkohsisht

N nj program njkohsisht mund t definohen dhe t shfrytzohen disa grupe. Pastaj, pr secilin prej tyre mund t deklarohen variablat prkatse. Shembull Programi enum15, prmes s cilit tregohet definimi i dy grupeve dhe shfrytzimi i tyre.
// Programi enum15 #include <iostream> using namespace std; enum perioda { paradite, pasdite, mbremje, pasmesnate, }; enum koha
Numrimet 29
{ dite, nate, }; int main() { int ora; perioda alfa; koha beta; cout << "\nShnoje orn mes 0 dhe 24: "; cin >> ora; if ((ora >=5) && (ora <= 12)) { alfa=paradite; beta=dite; } else if ((ora >12) && (ora <= 18)) { alfa=pasdite; beta=dite; } else if ((ora >18) && (ora <= 24)) { alfa=mbremje; beta=nate; } else { alfa=pasmesnate; beta=nate; } cout << "\nN orn e zgjedhur sht "; switch (alfa) { case paradite: cout << "paradit"; break; case pasdite: cout << "pasdit"; break;
case mbremje: cout << "mbrmje"; break; case pasmesnate: cout << "pasmesnat"; break; } cout << "\nJasht sht "; if (beta==dite) cout << "dit"; else cout << "nat"; cout << "\n\n"; return 0; }
N program, fillimisht jan prcaktuar grupet perioda dhe koha, ashtu si shihet m sipr. Pastaj, prmes komandave:
perioda alfa; koha beta;
jan deklaruar variablat alfa dhe beta, t tipeve perioda dhe koha prkatsisht. N pjesn vijuese t programit sht parapar q, duke ia dhn kompjuterit si vler hyrse orn aktuale (nj numr t plot mes 0 dhe 24), prmes komandave if t zgjedhen vlerat e variablave alfa dhe beta, nga vlerat e mundshme t grupeve prkatse. Zgjedhja bhet n baz t intervaleve kohore, duke e kontrolluar vlern e variabls ora, ashtu si shihet n pjesn prkatse t programit. Nnkuptohet se intervalet e prcaktuara ktu, realisht mund t merren edhe ndryshe, n ka ka ndikim edhe stina e vitit, s cils ato i prkasin. Prmes degzimeve n pjesn e fundit t programit, duke i pasur parasysh vlerat e prcaktuara t variablave alfa dhe beta, shtypet mesazhi pr periodn kohore t dits, si dhe informata se a sht dit, ose nat. Nse, p.sh., kompjuterit si vler hyrse pr orn i jepet vlera 16, rezultati q shtypet n ekran do t duket si n Fig.2.13.
Fig.2.13
Numrimet 31 Pamja e ekranit pas ekzekutimit t programit enum15 Logjika e funksionimit t programit t dhn m sipr mbshtetet n dy parakushte: dita fillon n'orn 5 dhe nata - n'orn 18. Ngjashm, n nj program mund t definohen e t shfrytzohen edhe me shum grupe me t dhna t numruara. N nj program nuk lejohen grupime n t cilat prfshihen t dhna t njjta. P.sh., brenda nj programi nuk mund t shfrytzohen grupimet vijuese:
enum obligative{ Matematika ,Fizika,Kompjuterika,Kimia} enum zgjedhore{Programimi, Matematika ,Fiskultura}
sepse Matematika paraqitet n t dy grupimet njkohsisht.
T dhnat e numruara n nnprograme

T dhnat e numruara mund t shfrytzohen edhe si parametra t funksioneve. Njkohsisht, kto t dhna mund t merren edhe si rezultate nga nnprogramet. Shembull Programi enum16, i cili paraqet nj version t modifikuar t programit enum14, ashtu q pr shtypje t rezultatit ktu shfrytzohet funksioni shtypja.
// Programi enum16 #include <iostream> using namespace std; enum logjike {Jo,Po,Gabim}; void shtypja(logjike); int main() { logjike alfa; char h; cout << "\nVlera hyrse P pr Po, ose J pr Jo: "; cin >> h; switch (h) { case 'P':alfa=Po;break; case 'J':alfa=Jo;break; default:alfa=Gabim;break; }

shtypja(alfa); cout << "\n\n"; return 0; } void shtypja(logjike alfa) { cout << "\nVlera e variabls: " << alfa; cout << "\nPrgjigjja sht "; switch (alfa) { case Po:cout << "Po";break; case Jo:cout << "Jo";break; case Gabim:cout << "gabim";break; } return; }
N programin e dhn, prmes komands:

enum logjike {Jo,Po,Gabim};
sht prcaktuar grupi i numruar logjike, me tri variablat e tij: Jo, Po dhe Gabim. Njkohsisht, n kuadr t programit sht definuar nnprogrami shtypja, prmes s cilit shtypet teksti q i prgjigjet vlers s zgjedhur t variabls alfa. Gjat ekzekutimit t programit t dhn, kompjuterit fillimisht duhet t'i jepet vlera e variabls s tipit karakter h, e cila lexohet. Pastaj n baz t ksaj vlere, prmes degzimit switch(h), variabls alfa i shoqrohet njra nga tri vlerat e mundshme (Po, Jo ose Gabim). Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.2.14.

enum16
2
Strukturat
Definimi i strukturave t zakonshme 34 Deklarimi i variablave t tipit t strukturs 36 Qasja te komponentet e strukturs 37 Deklarimi direkt i variabls s strukturs 39 Inicializimi direkt i variablave 44 Llogaritje me variablat e strukturs 46 Ruajtja e rezultateve n struktur 49 Disa variabla t nj strukture 51 Prdorimi i operacionit t shoqrimit 60 Prdorimi i operatorve relacional 62 Disa struktura njkohsisht 65 Strukturat e ndrthurura 70 Strukturat si parametra t funksioneve 73 Disa nnprograme njkohsisht 88 Funksionet n komponentet e strukturave 90 Fushat n struktura 124 Fushat e strukturave 128
Tipet standarde t variablave q shfrytzohen n gjuhn C++ ofrojn mundsi t shumta pr ruajtjen dhe prpunimin e t dhnave. N program, me deklarimin e tipit t nj variable, prcaktohet sakt hapsira memoruese, q shfrytzohet prej saj, si dhe lloji i t dhnave q mund t ruhen n at hapsir. Me qllim t lehtsimit t puns me grumbuj t t dhnash t tipit t njjt, t cilat njihen edhe si t dhna homogjene, shfrytzohen fushat (vektort, matricat ose fushat shumdimensionale). Por, n gjuhn C++ mund t grupohen edhe t dhna t tipeve t ndryshme, prkatsisht t dhna heterogjene, duke krijuar tipe t reja t t dhnave, t cilat njihen si struktura (ang. structure). Brenda strukturave mund t prfshihen edhe t dhna t definuara nga vet shfrytzuesi, p.sh., si jan t dhnat e tipeve t numruara. Por, strukturat n vete mund t prmbajn edhe funksione prmes t cilve operohet me t dhnat e prfshira brenda ose jasht tyre.
Definimi i strukturave t zakonshme

Strukturat, para se t shfrytzohen, duhet t definohen, duke e prdorur komandn struct. Kjo komand n form t prgjithshme shkruhet:
struct e { t1 x1; t2 x2; ...... tn xn; };
ku jan:
e - emri i strukturs. t1, t2, , tn - tipet e t dhnave n komponentet e strukturs. x1, x2, , xn - variablat n komponentet e strukturs.
Variablat q prfshihen n struktur si dhe tipet e tyre shnohen brenda kllapave dhe njihen si antar t strukturs, ose edhe komponente t strukturs. Definimi i strukturs pfundon me pikpresje (;). Nse, p.sh., duam q t dhnat e tipeve t ndryshme t nj personi, si jan: emri, viti i lindjes dhe qyteti
Strukturat 35 i banimit, t'i marrim si komponente t strukturs me emr person, definimi prkats do t duket:
struct person { char emri[8]; int viti; char qyteti[10]; };
N kt mnyr, t dhnave t tipeve t ndryshme u sht shoqruar emri i prbashkt person, me ka lehtsohet ruajtja dhe shfrytzimi i tyre gjat prpunimit. Shembull Programi struct1, n t cilin sht definuar struktura person.
// Programi struct1 #include <iostream> using namespace std; struct person { char emri[8]; char qyteti[10]; int viti; }; int main() { }
Si shihet nga programi i dhn, ktu struktura sht definuar para programit. N fund t do komponente t prfshir n struktur shnohet pikpresja. Kurse, n trupin e programit nuk paraqitet asnj komand, prandaj edhe nse ai ekzekutohet nuk fitohen rezultate. Definimi i strukturs n fjal mund t duket edhe:
struct person { char emri[8],qyteti[10]; int viti; };
36 Programimi i orientuar n objekte Nga kjo shihet se gjat definimit t strukturs komponentet e saj prcaktohen duke i shfrytzuar rregullat q vlejn pr variablat e zakonshme.
Deklarimi i variablave t tipit t strukturs

Me definimin e nj strukture kompjuteri nuk rezervon vende n memorien e tij pr komponentet e saj, pavarsisht se deklarohen tipet e variablave prkatse. Por, me strukturn krijohet nj tip i ri i t dhnave, i cili pastaj mund t shfrytzohet pr deklarimin e tipeve t variablave, prkatsisht pr deklarimin e objekteve prkatse. N form t prgjithshme, deklarimi i variabls s tipit t strukturs s definuar, duket: e v; ku jan:
e - emri i strukturs. v - variabla e tipit t strukturs e.
Si shihet nga kjo form e prgjithshme, deklarimi i variabls s tipit t strukturs s definuar bhet plotsisht njlloj si deklarohen edhe variablat e tipeve t zakonshme. Pr variabln v thuhet edhe se paraqet nj objekt t strukturs e. Shembull Programi struct2, n t cilin shihet definimi i strukturs person dhe shfrytzimi i saj pr deklarimin e variabls studenti t tipit person.
// Programi struct2 #include <iostream> using namespace std; struct person { char emri[8],qyteti[10]; int viti; }; int main() { person studenti; }
Strukturat 37 N program, prmes deklarimit:

person studenti;
variabla studenti deklarohet e tipit person, i cili tip n fakt paraqet nj kopje t strukturs q sht definuar m par. Pas ktij deklarimi, n memorien e kompjuterit rezervohen vende pr variablat t cilat paraqiten n komponentet e strukturs, me radh t njjt me t ciln jan shnuar brenda saj. Nse ekzekutohet programi n fjal, meq n trupin e tij deklarohet variabla studenti, e cila nuk shfrytzohet, kompjuteri do t gjeneroj nj mesazh pr t na njoftuar me kt. Kopja e strukturs e cila krijohet pas deklarimit t nj variable t tipit t strukturs, ndryshe quhet instanc e strukturs (ang. instance of the structure), kurse variabla quhet variabl e strukturs (ang. structure variable), ose edhe objekt i strukturs (ang. structure object). Nga kjo q u tha m sipr mund t shihet qart se ku qndron dallimi mes fushave dhe strukturave. Te fushat, p.sh., si jan vektort ose matricat, t gjitha t dhnat brenda tyre jan t tipit t njjt. Kurse, komponentet e strukturs mund t prmbajn t dhna nga m t ndryshmet, t cilat u ngjajn regjistrimeve (ang. record), q shfrytzohen te bazat e t dhnave.
Qasja te komponentet e strukturs

Pr qasje tek antart e fushave t ndryshme shfrytzohen indekset prkatse, t shnuara brenda kllapave. Ndrkaq, qasja te komponentet e strukturs n form t prgjithshme duket:
v.x
ku jan:
v - variabla e strukturs. x - variabla e komponentes s strukturs. . - operatori pik (ang. dot operator) pr qasje te variabla e komponentes
s strukturs. Shembull Programi struct3, prmes s cilit tregohet qasja te komponentet e strukturs person.

// Programi struct3 #include <iostream> using namespace std; struct person { char emri[8],qyteti[10]; int viti; }; int main() { person studenti; cout << "\nT dhnat nga tastiera\n\n"; cout << "Emri .....: "; cin >> studenti.emri ; cout << "Qyteti ...: "; cin >> studenti.qyteti ; cout << "Viti .....: "; cin >> studenti.viti ; cout << "\n\nT dhnat e lexuara\n"; cout << "\nEmri .....: " << studenti.emri ; cout << "\nQyteti ...: " << studenti.qyteti ; cout << "\nViti .....: " << studenti.viti << "\n\n"; return 0; }
N program, tri variablave t prfshira n strukturn person, pas deklarimit t variabls studenti t tipit t ksaj strukture, u qasemi duke i shnuar ato n format:
studenti.emri studenti.qyteti studenti.viti
Nse ekzekutohet programi i dhn dhe pas mesazheve prkatse, prmes tastiers kompjuterit i jepen vlerat hyrse Jeta, Shkupi dhe 1983, n ekran do ta kemi pamjen e cila shihet n Fig.3.1.
Strukturat 39

struct3
Deklarimi direkt i variabls s strukturs

Gjat definimit t strukturs, njkohsisht edhe mund t deklarohet variabla prkatse e strukturs, gj q n form t prgjithshme duket:
struct e { t1 x1; t2 x2; ...... tn xn; } v;
ku jan:
e - emri i strukturs. t1, t2, , tn - tipet e t dhnave n komponentet e strukturs. x1, x2, , xn - variablat n komponentet e strukturs. v - variabla e deklaruar e strukturs.
Nse struktura e till krahasohet me definimin e prgjithshm, q sht dhn n fillim, qart shihet se n fund t saj sht shnuar edhe variabla v, me ka ajo deklarohet direkt e tipit t strukturs q definohet. Shembull Programi struct4a, prmes s cilit definohet struktura dita me variablat a dhe b dhe deklarohet variabla koha e tipit t asaj strukture.

// Programi struct4a #include <iostream> using namespace std; struct dita { int a; float b; } koha; int main() { cout << "\nShfrytzimi i variabls koha\n" << "-----------------------------"; cout << "\n\nVlera e variabls a: "; cin >> koha.a; cout << "\nVlera e variabls b: "; cin >> koha.b; cout << "\n\nVlera e lexuar a=" << koha.a; cout << "\nVlera e lexuar b=" << koha.b << "\n\n"; dita nata; cout << "\nShfrytzimi i variabls nata\n" << "-----------------------------"; cout << "\n\nVlera e variabls a: "; cin >> nata.a; cout << "\nVlera e variabls b: "; cin >> nata.b; cout << "\n\nVlera e lexuar a=" << nata.a; cout << "\nVlera e lexuar b=" << nata.b << "\n\n"; return 0; }
N program, prmes deklarimit:

struct dita { int a; float b; } koha;
Strukturat 41 definohet struktura dita dhe njkohsisht deklarohet variabla me emrin koha e tipit t strukturs s definuar. Pastaj lexohen dhe shtypen vlerat e variablave a dhe b t prfshira brenda komponenteve t variabls koha t strukturs, duke i shkruar n formn:
koha.a koha.b
N fund, prmes komands:

dita nata;
deklarohet variabla nata, e cila e paraqet nj variabl tjetr t strukturs dita. Pr qasje te variablat e komponenteve t strukturs nata, ato shkruhen n formn:
nata.a nata.b
Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.3.2, ku vlerat e variablave t komponenteve t strukturs kompjuterit i jepen prmes tastiers.
Fig.3.2 Pamja e ekranit pas ekzekutimit t programit struct4a
42 Programimi i orientuar n objekte Gjat definimit t strukturs dhe deklarimit t variabls prkatse, mund t shfrytzohet edhe forma e strukturs e cila nuk ka emr:
struct { t1 x1; t2 x2; ...... tn xn; } v;
ku jan:
t1, t2, , tn - tipet e t dhnave n komponentet e strukturs. x1, x2, , xn - variablat n komponentet e strukturs. v - variabla e deklaruar e strukturs.
Nse definimi i strukturs s till krahasohet me definimin e prgjithshm, q sht dhn n fillim, qart shihet se ktu struktura nuk ka emr. Por, variabla v, e cila sht shnuar n fund, deklarohet direkt e tipit t strukturs q definohet. Shembull Programi struct4b, prmes s cilit tregohet deklarimi direkt i variabls koha t strukturs me variablat a dhe b, e cila deklarohet brenda trupit t programit.
// Programi struct4b #include <iostream> using namespace std; int main() { struct { int a; float b; } koha; cout << "\n\nVlera e variabls a: "; cin >> koha.a; cout << "\nVlera e variabls b: "; cin >> koha.b; cout << "\n\nVlera e lexuar a=" << koha.a;
Strukturat 43
cout << "\nVlera e lexuar b=" << koha.b << "\n\n"; return 0; }
Meq struktura e definuar nuk ka emr, ajo nuk mund t shfrytzohet pr deklarimin e variablave t tjera. Por, n program mund t shfrytzohet vetm variabla koha, e cila sht deklaruar direkt gjat definimit t strukturs. Nse ekzekutohet programi i dhn, pr vlera t caktuara hyrse, t cilat kompjuterit i jepen prmes tastiers, rezultati n ekran do t duket si n Fig.3.3.

struct4b
Efekt t njjt mund t ket edhe deklarimi i strukturs jasht trupit t programit. Shembull Programi struct4c, prmes s cilit tregohet deklarimi direkt i variabls provimi t strukturs me variablat lenda, emri dhe nota, e cila deklarohet jasht trupit t programit.
// Programi struct4c #include <iostream> using namespace std; struct { char lenda[15]; char emri[10]; int nota; } provimi; int main() { cout << "\n\nT dhnat q lexohen";
cout << "\n\nLnda: "; cin >> provimi.lenda ; cout << "\nEmri i studentit: "; cin >> provimi.emri ; cout << "\nNota n provim: "; cin >> provimi.nota ; cout << "\n\nT dhnat e lexuara"; cout << << cout << << cout << << << return 0; } "\n\nLnda: " provimi.lenda ; "\nEmri i studentit: " provimi.emri ; "\nNota n provim: " provimi.nota "\n\n";
Edhe ktu variablat e komponenteve t strukturs provimi mund t shfrytzohen plotsisht njlloj si shfrytzohen variablat e strukturave q deklarohen brenda programit. Si gjat leximit, ashtu edhe gjat shtypjes, ato shkruhen n format:
provimi.lenda provimi.emri provimi.nota
Por, edhe n kt rast nuk mund t deklarohen variabla t tjera t strukturs s definuar, sepse ajo nuk ka emr.
Inicializimi direkt i variablave

Variablat t cilat prfshihen brenda komponenteve t nj strukture, gjat deklarimit t variabls s strukturs prkatse n program, mund t inicializohen direkt me vlera. Shembull Programi struct5, prmes s cilit tregohet inicializimi direkt i variablave t strukturs dhe shtypja e vlerave t tyre.
Strukturat 45
// Programi struct5 #include <iostream> using namespace std; struct brinjet { double a,b; }; int main() { brinjet trek = {4.5,7.4}; cout << << << cout << << << return 0; } "\nVlerat e variablave t strukturs" "\n\nVlera e brinjs a: " trek.a; "\nVlera e brinjs b: " trek.b "\n\n";
N program, fillimisht, sht definuar struktura brinjet me dy komponente. Variablat a dhe b t komponenteve t strukturs n fjal jan deklaruar t tipit double. Pastaj, brenda programit, prmes shprehjes:
brinjet trek = {4.5,7.4};
sht deklaruar variabla trek e tipit t strukturs brinjet. Njkohsisht, gjat deklarimit t ksaj strukture, pas barazimit, brenda kllapave jan prcaktuar edhe vlerat e variablave a dhe b t komponenteve t strukturs. N fund, prmes komandave prkatse, kompjuterit i sht urdhruar q t'i shtyp vlerat 4.5 dhe 7.4 t variablave n fjal. Formalisht, definimi i strukturs s prmendur m sipr mund t bhet edhe kshtu:
struct brinjet {double a,b;};
gj q sht e ngjashme me shprehjen:

e cila shfrytzohet gjat inicializimit t variablave t prfshira n komponentet e strukturs.
Llogaritje me variablat e strukturs

Variablat e prfshira n struktur mund t shfrytzohen gjat llogaritjeve t ndryshme, plotsisht njlloj si shfrytzohen edhe variablat e zakonshme. Por, gjat ksaj, para variablave duhet t shnohet edhe emri i strukturs dhe pika si operator pr qasje antarve t strukturs. Shembull Programi struct6, prmes s cilit llogaritet siprfaqja s e trekndshit knddrejt, brinjt e t cilit prfshihen n komponentet e variabls trek t strukturs brinjet.
// Programi struct6 #include <iostream> using namespace std; struct brinjet { double a,b; }; int main() { brinjet trek = {4.5,7.4}; double s; cout << << << cout << << "\nVlerat e variablave t strukturs" "\n\nVlera e brinjs a: " trek.a; "\nVlera e brinjs b: " trek.b;
s=(trek.a*trek.b)/2; cout << "\n\nSiprfaqja e trekndshit s=" << s << "\n\n"; return 0; }
Meq n matematik siprfaqja s e trekndshit knddrejt me brinjt a dhe b llogaritet prmes shprehjes:
s = a b 2
Strukturat 47 n program shprehja prkatse pr llogaritjen e saj sht shkruar:

s=(trek.a*trek.b)/2;
Rezultati q fitohet n ekran, pas ekzekutimit t programit t dhn, do t duket si n Fig.3.4.
Fig.3.4 Pamja e ekranit pas ekzekutimit t programit struct6 Nse variablat e strukturs paraqiten n m shum shprehje, shfrytzimi i tyre i bn shprehjet m t gjata, sepse para do variable duhet t shnohet emri i strukturs dhe pika si operator pr qasje tek antari i komponentes s strukturs. Me qllim t shfrytzimit t shprehjeve t zakonshme, vlerat e variablave t strukturs mund t ruhen edhe n variabla t zakonshme, t cilat nuk dallojn nga variablat e komponenteve t strukturs. Shembull Programi struct7, i cili paraqet nj version t modifikuar t programit struct6, n t cilin sht shtuar edhe llogaritja e brinjs c t trekndshit dhe e perimetrit p t tij.
// Programi struct7 #include <iostream> #include <math.h> using namespace std; struct brinjet { double a,b; }; int main() { brinjet trek = {4.5,7.4}; double a,b,c,s,p; a=trek.a; b=trek.b;
cout << << << cout << <<
"\nVlerat e variablave t strukturs" "\n\nVlera e brinjs a: " a; "\nVlera e brinjs b: " b;
s=(a*b)/2; cout << "\n\nSiprfaqja e trekndshit s=" << s; c=sqrt(a*a+b*b); cout << "\nGjatsia e brinjs c=" << c; p=a+b+c; cout << "\nPerimetri i trekndshit p=" << p << "\n\n"; return 0; }
N fillim t programit, prmes shprehjeve:

a=trek.a; b=trek.b;
vlerat e variablave t komponenteve t strukturs ruhen te variablat e veanta a dhe b (emrat e ktyre variablave mund t zgjedhen lirisht edhe ndryshe). N program, pr llogaritje t gjatsis s brinjs c sht shfrytzuar shprehja:
c = a2 + b2
e nxjerr nga Teorema e Pitagors:

c2 = a2 + b2
Pr llogaritje t perimetrit p t trekndshit sht shfrytzuar shprehja e zakonshme:

p = a + b + c
Strukturat 49 Pas ekzekutimit t programit, pr vlerat e brinjve 4.5 dhe 7.4 t cilat kompjuterit i jan dhn gjat deklarimit t variabls trek t tipit brinjet, rezultati n ekran do t duket si n Fig.3.5.
Fig.3.5 Pamja e ekranit pas ekzekutimit t programit struct7
Ruajtja e rezultateve n struktur

Pr ruajtjen e rezultateve t llogaritjeve t ndryshme mund t shfrytzohen edhe variablat e komponenteve t strukturs. Shembull Programi structA, prmes s cilit llogaritet vlera e faktorielit:
F = (2m n + 1)!
nse variablat m dhe n dhe rezultati F ruhen n komponentet e strukturs Alfa.

// Programi structSa #include <iostream> using namespace std;
struct Alfa { int m,n; double F; };

int main() { Alfa Fakt; int i; cout << "\nVlerat hyrse" << "\n\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"; return 0; }
Ktu, fillimisht, sht definuar struktura Alfa, n komponentet e s cils paraqiten variablat m, n dhe F. Pastaj deklarohet variabla Fakt e tipit t strukturs Alfa, n variablat e komponenteve t s cils ruhen dy vlerat e lexuara Fakt.m dhe Fakt.n. N fund, duke e shfrytzuar pjesn e programit:
Fakt.F=1; for (i=1;i<=(2*Fakt.m-Fakt.n+1);i++) Fakt.F=Fakt.F*i;
prmes unazs for llogaritet vlera e faktorielit. Si shihet nga komandat e dhna, n ann e majt t barazimit paraqitet variabla Fakt.F, gj q d.m.th. se rezultati i llogaritjes s faktorielit prcillet te variabla F e strukturs. Meq edhe n komandn cout paraqitet kjo variabl, vlera e faktorielit, q shtypet n ekran, do t duket si n Fig.3.6.

structA
Gjat zgjedhjes s problemit t dhn struktura shfrytzohet vetm me qllim q t tregohet prdorimi i saj. Zgjedhja do t jet m e thjesht pa e shfrytzuar strukturn, ashtu si shihet n vijim.
// Programi structSb #include <iostream> using namespace std;
Strukturat 51
int main() { int m,n,i; double F; cout << "\nVlerat hyrse" << "\n\nVariabla m: "; cin >> m; cout << "\nVariabla n: "; cin >> n;
F=1; for (i=1;i<=(2*m-n+1);i++) F=F*i;

cout << "\nVlera e llogaritur F=" << F << "\n\n"; return 0; }
Ktu, variablat q shfrytzohen jan deklaruar si variabla t zakonshme n fillim t programit. Nse ekzekutohet programi i dhn, pr vlerat hyrse t variablave q lexohen, rezultati nuk do t dalloj aspak nga ai q u dha n Fig.3.6.
Disa variabla t nj strukture

Struktura e definuar mund t shfrytzohet pr deklarimin e disa variablave brenda programit t tipit t strukturs s definuar. Ky deklarim bhet pasi t jet definuar struktura, ose edhe gjat definimit t strukturs.
Deklarimi pasi sht definuar struktura

Pr deklarimin e njkohshm t disa variablave t strukturs, shfrytzohet shprehja e forms:
e v1,v2,...,vm;
ku jan:
e - emri i strukturs. v1, v2,..., vm - variablat t cilat deklarohen t tipit t strukturs e.
Kshtu, p.sh., deklarimi i variablave profesori dhe studenti t tipit person (q si shembull u prmend m sipr) bhet njlloj si deklarohen tipet e variablave t zakonshme:
person profesori; person studenti;
Ky deklarim mund t bhet m thjesht edhe n nj rresht:

person profesori,studenti;
ku, si shihet, fillimisht, shnohet tipi dhe pastaj variablat t ndara mes vete me presje. Kjo duket njlloj si edhe gjat deklarimit, p.sh., t variablave x dhe y si variabla t zakonshme t tipit int:
int x,y;
Shembull
Programi struct8, prmes s cilit tregohet shfrytzimi i dy variablave t strukturs person.
// Programi struct8 #include <iostream> using namespace std;
struct person { char emri[8],qyteti[10]; int viti; };

int main() { person profesori,studenti; cout << "\nT dhnat nga tastiera\n\n"; cout << "Qyteti i profesorit ...: "; cin >> profesori.qyteti; cout << "Qyteti i studentit ....: "; cin >> studenti.qyteti; cout << "\n\nT dhnat e lexuara\n"; cout << "\nProfesori sht nga " << profesori.qyteti;
Strukturat 53
cout << "\nStudenti sht nga " << studenti.qyteti << "\n\n"; return 0; }
N programin e dhn, fillimisht, sht deklaruar struktura person ashtu si sht shpjeguar edhe n shembujt e msiprm. Pastaj, duke e shfrytzuar kt tip t ri t t dhnave, prmes shprehjes:
person profesori,studenti;
jan deklaruar dy variabla t tipit person. Si rezultat i deklarimit n fjal, variablat profesori dhe studenti do t'i ken strukturat e njjta me strukturn person. N pjesn vijuese t programit sht parapar q, pasi t lexohen emrat e qyteteve t profesorit dhe t studentit, ato edhe t shtypen. Pas ekzekutimit t programit, nse prmes tastiers kompjuterit i jepen qytetet Prishtina dhe Shkupi, rezultati n ekran do t duket si n Fig.3.7.
Fig.3.7 Pamja e ekranit pas ekzekutimit t programit struct8 Gjat shfrytzimit t variablave t tipit t strukturs, operohet me emrat e variablave t cilat jan prfshir n definicionin e saj, duke e shnuar para operatorit pr qasje n struktur (para piks) emrin e variabls prkatse. Kshtu, n programin e dhn m sipr shihet qart shfrytzimi i variabls emri te dy variablat profesori dhe studenti, t cilat jan deklaruar t tipit t strukturs person, duke i shkruar n format:
profesori.emri studenti.emri
Ngjashm veprohet edhe nse shfrytzohen dy variablat e tjera t strukturs person, t cilat duhet t shkruhen:
profesori.viti studenti.viti
Shembull
Programi struct9 prmes s cilit tregohet prdorimi i dy variablave trek dhe kater t strukturs brinjet e cila sht shfrytzuar m par.
struct brinjet { double a,b; };

int main() { brinjet trek = {4.5,7.4}; brinjet kater = {6,4}; double st,sk; cout << << << cout << << "\nVariabla trek e strukturs brinjet" "\n\nVlera e brinjs a: " trek.a; "\nVlera e brinjs b: " trek.b;
cout << "\n\nVariabla kater e strukturs brinjet"; cout << << cout << << "\n\nVlera e brinjs a: " kater.a; "\nVlera e brinjs b: " kater.b;
st=(trek.a*trek.b)/2; sk=kater.a*kater.b;
cout << << << << << return 0; } "\n\nSiprfaqja e trekndshit st=" st "\nSiprfaqja e katrkndshit sk=" sk "\n\n";
Strukturat 55
N program jan llogaritur dhe jan shtypur siprfaqet e trekndshit (st) dhe t katrkndshit knddrejt (sk), t cilat n matematik llogariten prmes shprehjeve:
st = sk a b 2 = a b
Variablat e strukturs brinjet, e cila sht definuar, jan deklaruar n fillim t programit prmes shprehjeve:
brinjet trek = {4.5,7.4}; brinjet kater = {6,4};
Ktu, gjat deklarimit, njkohsisht, brinjve t trekndshit dhe t katrkndshit u jan ndar vlera, duke i shnuar ato brenda kllapave. Rezultati i cili fitohet pas ekzekutimit t programit t dhn, do t duket si n Fig.3.8.
Deklarimi dhe inicializimi i dy variablave trek dhe kater t strukturs

brinjet mund t bhet edhe n kt mnyr:
brinjet trek = {4.5,7.4},kater = {6,4};
Deklarimi gjat definimit t strukturs

M par u shpjegue deklarimi i variabls s strukturs gjat definimit t saj. Plotsisht njlloj do t duket komanda struct edhe nse shfrytzohet pr deklarimin e njkohshm t m shum variablave t nj strukture:
struct e { t1 x1; t2 x2; ...... tn xn; } v1,v2,...,vm;
ku jan:
e - emri i strukturs. t1, t2, , tn - tipet e t dhnave n komponentet e strukturs. x1, x2, , xn - variablat n komponentet e strukturs. v1, v2,..., vm - variablat t cilat deklarohen t tipit t strukturs e.
Definimi i strukturs n fjal mund t bhet para programit, ose edhe brenda programit. Shembull Pjesa fillestare e programit struct10a, i cili e paraqet nj version t modifikuar t programit struct9, prmes s cilit tregohet deklarimi i variablave trek dhe kater gjat definimit t strukturs brinjet.
// Programi struct10a #include <iostream> using namespace std; struct brinjet { double a,b; } trek,kater; int main() { trek.a = 4.5; trek.b = 7.4; kater.a = 6; kater.b = 4; double st,sk; ..................... return 0;
Strukturat 57
}
Si shihet nga pjesa e dhn e programit, gjat definimit t strukturs

brinjet, njkohsisht, jan deklaruar edhe variablat trek dhe kater t ksaj strukture. Pastaj, n program, variablave a dhe b brenda komponenteve t
strukturs, pr t dy variablat e strukturs, u jan ndar vlerat n rrug direkte. Nse pjesa tjetr e programit merret e njjt me at t programit struct9, pas ekzekutimit t tij, rezultati do t duket plotsisht njlloj si edhe ai i dhn n Fig.3.8. Gjat shfrytzimit t ksaj forme t deklarimit t variablave t strukturs, variablave brenda komponenteve t strukturs vlerat mund t'u ndahen edhe direkt. Shembull Pjesa fillestare e programit struct10b, si nj version i modifikuar i programit struct10a, prmes s cilit tregohet deklarimi i variablave trek dhe kater gjat definimit t strukturs brinjet dhe inicializimi i variablave t komponenteve prkatse a dhe b me vlera.
// Programi struct10b #include <iostream> using namespace std;
struct brinjet { double a,b; } trek={4.5,7.4},kater={6,4};

int main() { double st,sk; ..................... return 0; }
Nga kjo shihet se inicializimi me vlera i variablave brenda komponenteve t strukturs sht i ngjashm me at q sht dhn te programi struct9, por ktu kjo bhet gjat definimit t strukturs. Nse edhe n kt rast pjesa tjetr e programit merret e njjt me at t programit struct9, pas ekzekutimit t tij, rezultati nuk do t dalloj nga ai q sht dhn n Fig.3.8.
58 Programimi i orientuar n objekte Kur shfrytzohet forma e dhn, prmes emrit t strukturs, prve variablave q deklarohen gjat definimit t strukturs, n program mund t deklarohen edhe variabla t tjera t tipit t saj. Shembull Programi struct11, tek i cili gjat definimit t strukturs brinjet deklarohen variablat trek dhe kater, kurse brenda programit deklarohet edhe variabla rrethi e ksaj strukture.
struct brinjet { double a,b; } trek={4.5,7.4},kater={6,4};

int main() { brinjet rrethi={3.1415926,5}; double st,sk,sr; cout << "\nSiprfaqet e llogaritura:\n"; st=(trek.a*trek.b)/2; sk=kater.a*kater.b; sr=rrethi.a*(rrethi.b*rrethi.b); cout << << << << << << << return 0; } "\n\nSiprfaqja e trekndshit ... st=" st "\nSiprfaqja e katrkndshit . sk=" sk "\nSiprfaqja e rrethit ........ sr=" sr "\n\n";
N program, gjat definimit t strukturs brinjet, ashtu si edhe n shembujt struct10a dhe struct10b, jan deklaruar dhe jan inicializuar variablat trek dhe kater. Njkohsisht, por brenda programit, sht deklaruar dhe sht inicializuar struktura rrethi e tipit brinjet, n t ciln ruhet vlera e konstantes =3.1415926 dhe e rrezes s rrethit r=5. Meq n matematik siprfaqja e rrethit llogaritet prmes shprehjes:
Strukturat 59
s = r2
ktu, pasi vlerat prkatse ruhen te variablat e komponenteve t variabls

rrethi t strukturs brinjet, shprehja prkatse sht shkruar n formn:
sr=rrethi.a*(rrethi.b*rrethi.b);
N vend t pjess nn kllapa mund t shfrytzohet funksioni pow, kshtu:

sr=rrethi.a*pow(rrethi.b,2);
Nse ekzekutohet programi i dhn, rezultati q shtypet n ekran do t duket si n Fig.3.9.

struct11
Deklarimi i variablave t strukturs gjat definimit t saj mund t bhet edhe duke e ln strukturn pa emr, kshtu:
struct { t1 x1; t2 x2; ...... tn xn; } v1,v2,...,vm;
ku jan:
t1, t2, , tn - tipet e t dhnave n komponentet e strukturs. x1, x2, , xn - variablat n komponentet e strukturs. v1, v2,..., vm - variablat t cilat deklarohen t tipit t strukturs.
N kt rast, variablat e deklaruara shfrytzohen ashtu si u shpjegua edhe m sipr. Por, ktu nuk mund t deklarohen variabla t tjera t tipit t strukturs s definuar, prve atyre q jan deklaruar gjat definimit t saj, sepse struktura nuk ka emr.
60 Programimi i orientuar n objekte Shembull Programi struct12, i ngjashm me programin struct11, tek i cili struktura definohet pa emr dhe njkohsisht gjat ksaj deklarohen dhe inicializohen variablat trek, kater dhe rrethi.
// Programi struct12 #include <iostream> #include <math.h> using namespace std;
struct { double a,b; } trek={4.5,7.4},kater={6,4},rrethi={3.1415926,1};

int main() { double st,sk,sr; ..................... return 0; }
Ktu, inicializimi i variablave t strukturs nuk sht i domosdoshm. Nse pjesa tjetr e programit merret plotsisht e njjt me at q shihet te programi struct11, rezultati q fitohet n ekran me ekzekutimin e tij do t duket ashtu si sht dhn n Fig.3.9.
Prdorimi i operacionit t shoqrimit

Nse n program jan deklaruar dy variabla s1 dhe s2 t strukturs s, prmes operacionit t shoqrimit:
s1=s2;
vlerat e variablave t komponenteve t variabls s2 u shoqrohen variablave prkatse t komponenteve t variabls s1.
Strukturat 61 Shembull Programi struct13 prmes s cilit tregohet shoqrimi i vlerave t variablave t komponenteve t variabls trek t strukturs brinjet, e cila sht shfrytzuar n shembujt e msiprm, variablave prkatse t komponenteve t variabls kater.
// Programi struct13 #include <iostream> using namespace std; struct brinjet { double a,b; }; int main() { brinjet trek = {4.5,7.4}; brinjet kater;
kater=trek;
cout << "\nVlerat e variablave n dy strukturat"; cout << "\n\nBrinjt e trekndshit:" << "\n\nBrinja a: " << trek.a << "\nBrinja b: " << trek.b; cout << "\n\nBrinjt e katrkndshit:" << "\n\nBrinja a: " << kater.a << "\nBrinja b: " << kater.b << "\n\n"; return 0; }
N fillim t programit t dhn, gjat deklarimit t variablave trek dhe

kater t strukturs brinjet, prmes deklarimit:
variablave t komponenteve t variabls trek u jan shoqruar vlerat prkatse. Pastaj, prmes shprehjes:
kater=trek;
62 Programimi i orientuar n objekte prkatsisht me operacionin e shoqrimit, variablave t komponenteve t variabls kater:
kater.a kater.b
u shoqrohen vlerat e variablave prkatse t komponenteve t variabls trek. Nse ekzekutohet programi, rezultati n ekran do t duket si n Fig.3.10.

struct13
Nga rezultati i dhn shihet se brinjt e trekndshit dhe t katrkndshit jan t barabarta, gj q sht rezultat i barazimit t dy variablave t strukturs. Brinjve t katrkndshit n programin e msiprm mund t'u shoqrohen vlerat e brinjve t trekndshit, nse n vend t shprehjes:
kater=trek;
pr seciln komponente shfrytzohet operacioni i barazimit:

kater.a=trek.a; kater.b=trek.b;
Prdorimi i operatorve relacional

Operatort relacional nuk mund t zbatohen direkt mbi strukturat, por vetm mbi komponentet prkatse t tyre. Shembull Programi struct14, prmes s cilit tregohet krahasimi i vlerave t variablave t dy komponenteve t strukturs brinjet.
Strukturat 63

int main() { brinjet kater; double s; cout << "\nVlera e brinjs a: "; cin >> kater.a; cout << "\nVlera e brinjs b: "; cin >> kater.b; s=kater.a*kater.b;
if (kater.a==kater.b) cout << "\nSiprfaqja e katrorit s=" << s << "\n\n"; else cout << "\nSiprfaqja e katrkndshit s=" << s << "\n\n"; return 0; }
Ktu, fillimisht, sht definuar struktura brinjet, e cila prmban dy komponente me variablat a dhe b. Pastaj, prmes shprehjes:
brinjet kater;
n program sht deklaruar variabla kater e strukturs brinjet, n t ciln sht menduar t ruhen vlerat e dy brinjve t katrkndshit knddrejt. N vijim, prmes komandave prkatse, sht parapar t lexohen vlerat e dy brinjve n fjal dhe me shprehjen:
s=kater.a*kater.b;
t llogaritet edhe vlera e siprfaqes s katrkndshit. Kurse, prmes komands:

if (kater.a==kater.b)
64 Programimi i orientuar n objekte krahasohen vlerat e dy brinjve t katrkndshit. Nse brinjt jan t barabarta, rezultati n ekran do t duket si n Fig.3.11, ku, si shihet, shtypet siprfaqja e katrorit (meq dy brinjt jan t barabarta).

struct14, pr dy vlera t njjta t brinjve
Por, nse prmes tastiers, kompjuterit pr brinjt i jepen dy vlera t ndryshme, rezultati do t duket si n Fig.3.12.
Fig.3.12 Pamja e ekranit pas ekzekutimit t programit struct14, pr dy vlera t

ndryshme t brinjve
Plotsisht njlloj mund t krahasohen edhe variablat e komponenteve t dy variablave t nj strukture. Shembull Programi struct15, prmes s cilit tregohet krahasimi i vlerave t variablave t komponenteve t dy variablave t nj strukture.

int main() { brinjet kater; brinjet trek; cout << "\nBrinja a e katrkndshit: "; cin >> kater.a;
Strukturat 65
cout << "\nBrinja a e trekndshit: "; cin >> trek.a;
if (kater.a==trek.a) cout << "\nBrinjt e barabarta"; else cout << "\nBrinjt e pabarabarta"; cout << "\n\n"; return 0; }
Fillimisht, n program sht definuar struktura brinjet ashtu si sht shpjeguar edhe m par. Pastaj, duke e shfrytzuar strukturn n fjal, prmes shprehjeve:
brinjet kater; brinjet trek;
jan deklaruar dy variablat e ksaj strukture, n t cilat sht menduar t ruhen vlerat e brinjve prkatse t katrkndshit dhe trekndshit. N fund, prmes komands:
if (kater.a==trek.a)
gjendet se a jan t barabarta brinjt a t katrkndshit dhe t trekndshit. Nse, p.sh., pr kto dy brinj kompjuterit prmes tastiers i jepen vlerat 7 dhe 5, rezultati n ekran do t duket si n Fig.3.13.
Fig.3.13 Pamja e ekranit pas ekzekutimit t programit struct15, pr dy vlera t

ndryshme t brinjve a prkatse
Disa struktura njkohsisht

N nj program njkohsisht mund t definohen edhe disa struktura. Gjat ksaj do struktur duhet ta ket emrin dhe komponentet me variablat q prfshihen brenda saj.
Shembull
Programi struct16, prmes s cilit tregohet shfrytzimi i dy strukturave njkohsisht, strukturs brinjet dhe strukturs rrezja.
struct brinjet { double a,b; }; struct rrezja { double r; };

int main() { brinjet kater = {6,4}; rrezja rrethi = {5}; double sk,pk,sr,pr; const double pi=3.1415926; cout << << << cout << << cout << << "\nVlerat e variablave n dy strukturat" "\n\nVlera e brinjs a: " kater.a; "\nVlera e brinjs b: " kater.b; "\nVlera e rrezes: " rrethi.r;
sk=(kater.a*kater.b); pk=2*kater.a+2*kater.b;
cout << << << << "\n\nSiprfaqja e katrkndshit sk=" sk "\nPerimetri i katrkndshit pk=" pk;
sr=pi*(rrethi.r*rrethi.r); pr=2*pi*rrethi.r;
Strukturat 67
cout << "\nSiprfaqja e rrethit sr=" << sr << "\nPerimetri i rrethit pr=" << pr << "\n\n"; return 0; }
N program, fillimisht, sht definuar struktura:

dhe pastaj edhe struktura:

struct rrezja { double r; };
Si antar t strukturs brinjet paraqiten dy brinjt a dhe b t katrkndshit, kurse te struktura rrezja prfshihet rrezja r e rrethit. N matematik, ashtu si sht shpjeguar edhe m par, pr llogaritjen e siprfaqes dhe t perimetrit t katrkndshit knddrejt shfrytzohen shprehjet:
sk = a b pk = 2 a + 2 b
Kurse, siprfaqja dhe perimetri i rrethit llogariten prmes shprehjeve:

sr = r 2 pr = 2 r
ku vlera e konstantes sht marr 3.1415926. Meq vlerat e variablave a, b dhe r n kt rast merren nga komponentet e variablave kater dhe rrethi t strukturave brinjet dhe rrezja, shprehjet prkatse pr llogaritjen e siprfaqes dhe t perimetrit t katrkndshit dhe t rrethit jan shkruar n kt form:
sk=(kater.a*kater.b); pk=2*kater.a+2*kater.b; sr=pi*(rrethi.r*rrethi.r);

pr=2*pi*rrethi.r;
Nse ekzekutohet programi i dhn, rezultati q fitohet n ekran do t duket si n Fig.3.14.
Fig.3.14 Pamja e ekranit pas ekzekutimit t programit struct16 Gjat definimit, brenda nj strukture variablat e komponenteve prkatse duhet t ken emra, t cilt dallohen mes vete. Por, dy struktura t ndryshme n komponentet e tyre mund t prmbajn edhe variabla me emra t njjt. Shembull Programi struct17, prmes s cilit tregohet shfrytzimi i dy strukturave njkohsisht n komponentet e t cilave paraqiten dy variabla me emra t njjt.
struct Dita { int x; float y; }; struct Nata { double x; };

int main() { Dita R={5,-8.5}; Nata F={16.5}; double z; cout << "\nVlerat e prfshira n strukturn R\n";
Strukturat 69
cout << << cout << << cout << cout << << "\nVlera x R.x; "\nVlera y R.y; "\n\nVlera "\nVlera x F.x; .....: " ....: " e prfshir n strukturn F\n"; .....: "
z=R.x+R.y+F.x;
cout << << << << return 0; } "\n\nVlera e llogaritur\n" "\nShuma z .....: " z "\n\n";
N programin e dhn, variabla x sht shfrytzuar njkohsisht n komponentet e strukturave Dita dhe Nata. Por, gjat shfrytzimit t vlerave prkatse, t prfshira n variablat e strukturave n fjal R dhe F, prcaktimi i komponenteve lidhet edhe me emrat e strukturave:
R.x R.y F.x
gj q shfrytzohet si gjat shtypjes s vlerave ashtu edhe gjat llogaritjes s shums:

z=R.x+R.y+F.x;
Nse ekzekutohet programi i dhn, rezultati do t duket si n Fig.3.15.
Strukturat e ndrthurura
Gjat definimit t nj strukture, n komponentet e saj mund t paraqiten variabla t strukturave t tjera, duke krijuar n kt mnyr struktura t ndrthurura. Strukturat e tilla paraqesin forma m komplekse t t dhnave dhe ndryshe njihen edhe si struktura hierarkike (ang. hierarchical structure). Shembull Programi struct18, prmes s cilit tregohet shfrytzimi i strukturave provim dhe person, prej t cilave njra struktur paraqitet edhe si komponente e strukturs s dyt.
struct provim { int nr; unsigned nota; };

struct person { char emri[8]; provim programimi; }; int main() { person studenti; cout << "\nT dhnat nga tastiera\n\n"; cout << "Emri ..............: "; cin >> studenti.emri; cout << "Numri i lnds ....: "; cin >> studenti.programimi.nr; cout << "Nota n provim ....: "; cin >> studenti.programimi.nota; cout << "\n\nT dhnat e lexuara\n"; cout << "\nEmri ..............: "
Strukturat 71
<< cout << << cout << << << return 0; }
studenti.emri; "\nNumri i lnds ....: " studenti.programimi.nr; "\nNota n provim ....: " studenti.programimi.nota "\n\n";
N programin e dhn definohen strukturat provim dhe person. N strukturn e par:

struct provim { int nr; unsigned nota; };
variablat nr dhe nota, q paraqiten n dy komponentet e saj, p.sh., mund t shfrytzohen pr ruajtjen e numrit rendor t lnds msimore n fakultet dhe t nots prkatse t studentit gjat provimit. Kurse si komponent e strukturs s dyt:
struct person { char emri[8]; provim programimi; };
paraqitet variabla programimi, e cila sht e tipit t strukturs s par provim. Prmes deklarimit:
person studenti;
n program sht deklaruar variabla studenti e tipit t strukturs person. Pastaj, variabls emri t komponentes s par t strukturs provim i qasemi duke e shkruar n form t zakonshme:
studenti.emri
Kurse, pr qasje te dy variablat e komponenteve t strukturs provim, prkatsisht te variabla programimi, e cila prfshihet n strukturn person, ato duhet t shkruhen n formn:
studenti.programimi.nr studenti.programimi.nota
72 Programimi i orientuar n objekte Nse ekzekutohet programi i dhn dhe prmes tastiers kompjuterit i jepet emri i studentit, numri rendor i lnds Programimi dhe nota me t ciln sht notuar studenti n kt lnd, rezultati n ekran do t duket si n Fig.3.16.

struct18
Inicializimi me vlera i variablave q paraqiten brenda strukturave t ndrthurura mund t bhet edhe gjat deklarimit t variablave prkatse. Shembull Programi struct18a, prmes s cilit tregohet inicializimi direkt me vlera i variablave q paraqiten brenda strukturave t ndrthurura provim dhe person.
// Programi struct18a #include <iostream> using namespace std; struct provim { int nr; unsigned nota; }; struct person { char emri[8]; provim programimi; }; int main() { person studenti={"Agim",{13,7}}; cout << "\n\nT dhnat e inicializuara\n"; cout << "\nEmri ..............: " << studenti.emri; cout << "\nNumri i lnds ....: "
Strukturat 73
<< studenti.programimi.nr; cout << "\nNota n provim ....: " << studenti.programimi.nota << "\n\n"; return 0; }
Pr inicializimin me vlera gjat deklarimit t variabls studenti t tipit

person sht shfrytzuar komanda:
person studenti={"Agim", {13,7}};
Ktu, emri Agim, i shnuar nn thonjza, i prgjigjet variabls emri, q paraqitet n komponenten e par t strukturs person. Kurse prmes iftit t dy numrave {13,7} inicializohen variablat nr dhe nota, q prfshihen n strukturn provim, e cila paraqitet si komponente e dyt e strukturs person. Nse ekzekutohet ky version i programit, rezultati do t duket i njjt me at q sht dhn n Fig.3.16. Nuk ekziston ndonj kufizim rreth numrit t strukturave, t cilat mund t ndrthuren mes vete. Por, nse ndrthuren m shum struktura, nnkuptohet se duhet t shtohet kujdesi pr mnyrn e qasjes te komponentet e strukturave t veanta.
Strukturat si parametra t funksioneve

Variablat e strukturave mund t paraqiten edhe si parametra t funksioneve. Gjat ksaj, si edhe pr t dhnat e zakonshme, parametrat formal dhe ata aktual duhet t prputhen mes vete pr nga: numri - sa ka parametra formal, aq duhet t ket edhe parametra aktual; tipi - tipin e njjt duhet ta ken parametrat formal dhe parametrat aktual prkats; radha e shkruarjes - parametrit formal n pozit t caktuar t'i prgjigjet parametr aktual me pozit t njjt. Programi struct19, prmes s cilit tregohet shfrytzimi i strukturs brinjet definimi i s cils sht shpjeguar m par, si parametr i funksionit Jeta.
Shembull
struct brinjet { double a,b; }; double Jeta(brinjet kater);

int main() { brinjet kater; double s; cout << "\nBrinja a: "; cin >> kater.a; cout << "\nBrinja b: "; cin >> kater.b;
s=Jeta(kater);
cout << "\nSiprfaqja s=" << s << "\n\n"; return 0; }
double Jeta(brinjet kater) { double x; x=kater.a*kater.b; return x; }
N program sht shfrytzuar nnprogrami Jeta, n t cilin si parametr formal paraqitet variabla kater e strukturs brinjet. Brenda nnprogramit, prmes shprehjes:
x=kater.a*kater.b;
llogaritet prodhimi i variablave a dhe b t komponenteve t strukturs kater. N fillim t programit sht shnuar prototipi i funksionit:
Strukturat 75
double Jeta(brinjet kater);
prmes s cilit kompjuteri njoftohet se n pjesn vijuese do t definohet nnprogrami Jeta, i cili si parametr formal e ka variabln kater t tipit t strukturs brinjet. Sikur edhe gjat puns me variabla t tipeve t zakonshm, prototipi i funksionit mund t deklarohet duke e shnuar vetm tipin (emrin e strukturs):
double Jeta(brinjet);
pa variabln prkatse. Nnprogrami Jeta thirret duke e shfrytzuar komandn:

s=Jeta(kater);
ku si parametr aktual prsri sht shfrytzuar struktura kater. Nse variablat a dhe b t komponenteve t strukturs kater i paraqesin vlerat e brinjve t katrkndshit knddrejt, vlera e cila ruhet te variabla s do t jet siprfaqja e katrkndshit, gj q n nnprogram prcaktohet prmes llogaritjes s vlers s variabls x. Pasi t ekzekutohet programi i dhn dhe prmes tastiers kompjuterit t'i jepen vlerat e brinjve a dhe b, rezultati n ekran do t duket ashtu si shihet n Fig.3.17.

struct19
Ktu, si parametr formal dhe parametr aktual sht marr variabla

kater e strukturs brinjet. Por, sikur edhe gjat operimit me variabla t
zakonshme, identifikatort e parametrave formal dhe t atyre aktual mund t merren edhe t ndryshm. Shembull Programi prmes s cilit tregohet shfrytzimi si parametr formal te funksioni Jeta i variabls Z t strukturs brinjet, kurse si parametr aktual - variabla kater e saj.
// Programi struct20a #include <iostream> using namespace std; struct brinjet { double a,b; };
double Jeta(brinjet Z);

int main() { brinjet kater; double s; cout << "\nBrinja a: "; cin >> kater.a; cout << "\nBrinja b: "; cin >> kater.b;
s=Jeta(kater);
double Jeta(brinjet Z) { double x; x=Z.a*Z.b; return x; }
Si shihet nga programi i dhn, si parametr formal te nnprogrami paraqitet variabla Z e strukturs brinjet (kjo variabl sht marr edhe te prototipi i funksionit). Kurse, gjat thirrjes s nnprogramit, si parametr aktual i saj shfrytzohet variabla kater e ksaj strukture. Te prototipi i nnprogramit nuk sht e domosdoshme t shkruhet emri i variabls s strukturs, por vetm tipi i saj, kshtu:
double Jeta(brinjet);
Strukturat 77
Nse ekzekutohet programi struct20a, pr vlera t caktuara hyrse t brinjve t katrkndshit rezultati do t duket si n Fig.3.18.

struct20a
Zgjidhja e problemit t msiprm do t duket m e thjesht, nse nuk shfrytzohet struktura, ashtu si sht dhn n vijim.
double Jeta(double a,double b);

int main() { double a,b,s; cout << "\nBrinja a: "; cin >> a; cout << "\nBrinja b: "; cin >> b;
s=Jeta(a,b);
double Jeta(double a,double b) { double x; x=a*b; return x; }
Ktu, parametrat formal dhe ata aktual te nnprogrami jan direkt vet brinjt a dhe b t katrkndshit, pa e marr si ndrmjetsues strukturn q u prmend m sipr. N versionin paraprak t programit, struktura sht
78 Programimi i orientuar n objekte shfrytzuar me qllim t shpjegimit t mnyrs s puns me struktura dhe jo si zgjidhje m optimale e problemit.
Funksione me parametra t przier

Si parametra t funksionit, prve variablave t strukturave mund t paraqiten edhe variabla t zakonshme t tipeve standard. Shembull Programi struct21, n t cilin si parametra t funksionit Dita, prve variabls s strukturs, paraqiten edhe variabla t tjera t tipeve standarde.
struct Koha { int g; float z,t; }; void Dita(Koha,float);

int main() { Koha beta; cout << "\nVlera g: "; cin >> beta.g; cout << "Vlera z: "; cin >> beta.z; cout << "Vlera t: "; cin >> beta.t;
Dita(beta,5.5);
return 0; } void Dita(Koha beta,float h) { float d,r;
d=3*h+beta.t;
Strukturat 79
r=beta.g*beta.t+2*h;
cout << "\nRezultatet: "; cout << "\n\nVlera d=" << d; cout << "\nVlera r=" << r << "\n\n"; return; }
N programin e dhn sht shfrytzuar funksioni Dita, tek i cili si parametra formal paraqiten: variabla beta e strukturs Koha variabla h e tipit standard float Duke i shfrytzuar variablat e komponenteve t strukturs beta dhe variabln h, n nnprogram llogariten vlerat e shprehjeve:
d=3*h+beta.t; r=beta.g*beta.t+2*h;
Meq n nnprogram sht parapar q rezultatet edhe t shtypen, gjat thirrjes s tij n program nuk prcillet asnj vler, para tij sht shnuar fjala void. N programin kryesor nnprogrami thirret kshtu:
Dita(beta,5.5);
ku si parametra aktual paraqiten variabla beta e strukturs Koha, si dhe vlera 5.5 me t cilin zvendsohet parametri formal h. Rezultati q fitohet n ekran pas ekzekutimit t programit t dhn, pr vlerat hyrse q kompjuterit i jepen prmes tastiers, do t duket si n Fig.3.19.

struct21
Ky rezultat fitohet prmes llogaritjeve vijuese:
d=3*5.5+4=20.5 r=6*4+2*5.5=35
Gjat deklarimit t variabls s strukturs e cila prfshihet n parametrat e nnprogramit, variablave n komponentet e saj mund t'u shoqrohen direkt vlerat. Shembull Programi struct22a, prmes s cilit llogaritet vlera e funksionit:
n+1
y = 2x + 4
i=2
(3i + 4)
duke e shfrytzuar nnprogramin Nata pr llogaritjen e pjess s dyt t shprehjes.

// Programi struct22a #include <iostream> using namespace std;
struct Gama { int a,b; float x,y; };

double Nata(int, Gama); int main() { int n=2;
Gama Jeta={2,n+1,3,4};
double x=5,y; y=2*x+Nata(4,Jeta); cout << "\nRezultati y=" << y << "\n\n"; return 0; } double Nata(int k,Gama Jeta) {
Strukturat 81
int i; double s,z; s=0; for (i=Jeta.a;i<=Jeta.b;i++) s=s+(Jeta.x*i+Jeta.y); z=k*s; return z; }
Me nnprogramin Nata definohet funksioni:

z = k
i=a
(x i +
y)
T dhnat a, b, x dhe y, t cilat lidhen me llogaritjen e shums s n nnprogram, ruhen te variabla Jeta e strukturs Gama. Kurse konstantja k, me t ciln shumzohet shuma, paraqitet si parametr i nnprogramit. N program, vlerat e variablave jepen direkt, duke i shnuar brenda kllapave, gjat deklarimit t variabls Jeta t strukturs Gama kshtu:
Gama Jeta={2,n+1,3,4};
Kurse n nnprogram, gjat llogaritjes s shums prmes unazs:

for (i=Jeta.a;i<=Jeta.b;i++) s=s+(Jeta.x*i+Jeta.y);
ku si shihet, vlera fillestare a e variabls i, vlera kufitare b e saj si dhe vlerat e variablave x dhe y brenda shums, merren nga variabla Jeta e strukturs Gama. Rezultati q fitohet n ekran pas ekzekutimit t programit t dhn do t duket si n Fig.3.20. Fig.3.20 Pamja e ekranit pas ekzekutimit t programit
struct22a
Vlera e llogaritur sht fituar duke e shfrytzuar shprehjen:

y=2*5+4*{(3*2+4)+(3*3+4)}=102
Llogaritja e vlers s funksionit n fjal sht m e thjesht, nse nuk shfrytzohet struktura. Por, si edhe n shembujt paraprak, versioni i llogaritjes s vlers s funksionit pa ndrmjetsimin e strukturs sht m i thjesht, ashtu si shihet n vijim.
// Programi struct22b

#include <iostream> using namespace std;
double Nata(int k,int a,int b,double x,double y);

int main() { int n=2; double x=5,y; y=2*x+Nata(4,2,n+1,3,4); cout << "\nRezultati y=" << y << "\n\n"; return 0; } double Nata(int k,int a,int b,double x,double y) { int i; double s,z; s=0; for (i=a;i<=b;i++) s=s+(x*i+y); z=k*s; return z; }
Ktu, duket m qart shfrytzimi i parametrave formal n nnprogram, si dhe zvendsimi i tyre me parametrat aktual gjat llogaritjes s vlers s funksionit.
Thirrja e prsritur e funksionit

Nnprogramet, t cilt si parametra formal prmbajn edhe variabla t strukturave, mund t thirren m shum her brenda nj programi. Shembull Programi struct23a, prmes s cilit llogariten vlerat e funksioneve:
n+2 i=1 n
y = x + 3 z =
(2i 5)
n+1
x + 2 (i + g) 3 (4i h) 3 i=1 i=2
Strukturat 83
struct Gama { int a,b; float x,y; }; double Nata(int,Gama);

int main() { int n=2; float g=3,h=4;
Gama Jeta1={1,n+2,2,-5}; Gama Jeta2={1,n,1,g}; Gama Jeta3={2,n+1,4,-h};

double x=5,y,z; y=x+Nata(3,Jeta1); cout << "\nVlera y=" << y; z=x/3+Nata(2,Jeta2)+Nata(-3,Jeta3); cout << "\nVlera z=" << z << "\n\n"; return 0; } double Nata(int k,Gama Jeta) { int i; double s,z; s=0; for (i=Jeta.a;i<=Jeta.b;i++) s=s+(Jeta.x*i+Jeta.y); z=k*s;

return z; }
N program jan deklaruar 3 variabla t strukturs Gama:

Gama Jeta1={1,n+2,2,-5}; Gama Jeta2={1,n,1,g}; Gama Jeta3={2,n+1,4,-h};
deklarim i cili mund t bhet edhe n nj rresht, kshtu:

Gama Jeta1={1,n+2,2,-5},Jeta2={1,n,1,g},Jeta3={2,n+1,4,-h};
N kllapat e secils nga variablat n fjal prfshihen vlerat t cilat kan t bjn me 3 shumat q paraqiten n dy shprehjet e funksioneve. Dy vlerat e para t variablave a dhe b n komponentet e strukturs u prgjigjen kufijve t shumave (kufiri i poshtr dhe kufiri i siprm). Kurse vlerat e variablave x dhe y n komponentet e strukturs u prgjigjen konstanteve para variabls i dhe n pjesn pas saj, t shprehjeve nn shumat. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.3.21. Fig.3.21 Pamja e ekranit pas ekzekutimit t programit
struct23a
N vijim, me qllim t krahasimit, sht dhn versioni i programit n t cilin nuk shfrytzohet struktura.
double Nata(int k,int a,int b,float x,float y);

int main() { int n=2; float g=3,h=4; double x=5,y,z;
Strukturat 85
y=x+Nata(3,1,n+2,2,-5); cout << "\nVlera y=" << y; z=x/3+Nata(2,1,n,1,g)+Nata(-3,2,n+1,4,-h); cout << "\nVlera z=" << z << "\n\n"; return 0; } double Nata(int k,int a,int b,float x,float y) { int i; double s,z; s=0; for (i=a;i<=b;i++) s=s+(x*i+y); z=k*s; return z; }
N programin e dhn shum qart duket shfrytzimi i parametrave formal gjat definimit t procedurs s llogaritjes s shums te nnprogrami Nata, si dhe zvendsimi i tyre me parametra aktual gjat tri thirrjeve t funksionit.
Disa struktura si parametra t funksioneve

N nj funksion, si parametra njkohsisht mund t shfrytzohen dy e m shum struktura. Shembull Programi struct24a, prmes s cilit llogaritet vlera e funksionit:
h = 3 max(a, b, c) + (2m + n 1)!5
duke e shfrytzuar nnprogramin Jeta pr llogaritjen dhe shtypjen e vlers maksimale mes tre numrave a, b dhe c, si dhe vlers s faktorielit.
struct Alfa { double a,b,c; }; struct Beta { int m,n; };

double Jeta(Alfa,Beta); int main() { int m=1,n=2; double h;
Alfa Dita={2,4,3}; Beta Nata={m,n};

h=Jeta(Dita,Nata); cout << "\nVlera e funksionit h=" << h << "\n\n"; return 0; }
double Jeta(Alfa Dita,Beta Nata) { int i; double x,F,h;

if (Dita.a>Dita.b) { if (Dita.a>Dita.c) x=Dita.a; } else { if (Dita.b>Dita.c) x=Dita.b; else x=Dita.c; } cout << "\nVlera m e madhe x="
Strukturat 87
<< x; F=1; for (i=1;i<=(2* Nata.m+Nata.n-1);i++) F=F*i; cout << "\nVlera e faktorielit F=" << F;
h=3*x+F-5;
return h; }
Prmes deklarimit t strukturave prkatse, variablat a, b dhe c jan prfshir n komponentet e strukturs Alfa, kurse variablat m dhe n - n strukturn Beta. Gjat deklarimit t variablave Dita dhe Nata t strukturave:
Alfa Dita={2,4,3}; Beta Nata={m,n};
variablat e komponenteve prkatse edhe jan inicializuar me vlera. Pastaj, kto dy variabla jan shfrytzuar si parametra t funksionit Jeta. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.3.22.

struct24a
Vlera maksimale x dhe faktorieli F llogariten dhe shtypen n nnprogram. Kurse, vlera e funksionit h llogaritet n programin kryesor duke e shfrytzuar edhe nnprogramin Jeta, ku si parametra aktual prsri paraqiten variablat Dita dhe Nata t strukturave Alfa dhe Beta. Nse programi i dhn shkruhet duke mos i shfrytzuar strukturat, do t jet m i thjesht, ashtu si sht dhn n vijim.
double Jeta(double a,double b,double c,int m,int n);

int main() {

int m=1,n=2; double h; h=Jeta(2,4,3,m,n); cout << "\nVlera e funksionit h=" << h << "\n\n"; return 0; }
double Jeta(double a,double b,double c,int m,int n) { int i; double x,F,h;

if (a>b) { if (a>c) x=a; } else { if (b>c) x=b; else x=c; } cout << "\nVlera m e madhe x=" << x; F=1; for (i=1;i<=(2*m+n-1);i++) F=F*i; cout << "\nVlera e faktorielit F=" << F;
h=3*x+F-5;
return h; }
Ktu, 5 variablat t cilat n programin paraprak ishin prfshir n komponentet e strukturave Alfa dhe Beta, jan vendosur direkt si parametra t nnprogramit Jeta.
Strukturat 89
Disa nnprograme njkohsisht

Variablat e strukturave pa ndonj kufizim mund t prdoren njkohsisht n m shum nnprograme.
Shembull
Programi struct25, prmes s cilit llogaritet vlera e funksionit nga detyra paraprake:
h = 3 max(a, b, c) + (2m + n 1)!5
por duke i shfrytzuar nnprogramet max dhe fakt prmes t cilve gjendet vlera maksimale mes tre numrave a, b dhe c, si dhe vlera e faktorielit.
// Programi struct25 #include <iostream> using namespace std; struct Alfa { double a,b,c; }; struct Beta { int m,n; }; double max(Alfa); double fakt(Beta); int main() { int m=1,n=2; double h; Alfa Dita={2,4,3}; Beta Nata={m,n}; h=3*max(Dita)+fakt(Nata)-5; cout << "\nVlera e funksionit h=" << h << "\n\n"; return 0; }
double max(Alfa Dita) { double x;

if (Dita.a>Dita.b) { if (Dita.a>Dita.c) x=Dita.a; } else { if (Dita.b>Dita.c) x=Dita.b; else x=Dita.c; } cout << "\nVlera m e madhe x=" << x; return x; }
double fakt(Beta Nata) { int i; double F; F=1; for (i=1;i<=(2*Nata.m+Nata.n-1);i++) F=F*i; cout << "\nVlera e faktorielit F=" << F; return F; }
Edhe ktu variablat a, b dhe c prfshihen n komponentet e strukturs Alfa, kurse variablat m dhe n - n strukturn Beta. Pastaj, variablat Dita dhe Nata t strukturave shfrytzohen si parametra t funksioneve max dhe fakt. Nse ekzekutohet programi i dhn, rezultati do t duket ashtu si sht dhn n Fig.3.22.
Funksionet n komponentet e strukturave

Prve variablave, n komponentet e strukturave mund t paraqiten edhe funksionet. Gjat ksaj, n form t prgjithshme struktura shkruhet kshtu:
Strukturat 91
struct e { t1 y1; t2 y2; ...... tn yn; };
ku jan:
e - emri i strukturs. t1, t2, , tn - tipet e t dhnave ose t funksioneve n komponentet e
strukturs.
y1, y2, , yn - variablat ose funksionet n komponentet e strukturs.
N program, variabla e strukturs s till deklarohet plotsisht njlloj si deklarohen variablat e strukturave t zakonshme. Kurse, edhe funksionet q paraqiten n komponentet e strukturs thirren ashtu si shfrytzohen variablat brenda komponenteve t saj.
Funksionet pa parametra formal

Nse gjat llogaritjeve brenda funksioneve shfrytzohen vetm variablat t cilat prfshihen n komponentet e strukturave ku ato definohen, n kllapat e tyre nuk shnohet asnj parametr formal. Por, definimi i funksioneve mund t bhet brenda vet strukturs, ose edhe jasht saj.
Definimi brenda strukturs

Funksionet brenda strukturs definohen plotsisht njlloj si definohen edhe funksionet e zakonshme. Shembull Programi struct26, prmes s cilit llogaritet vlera e funksionit:
y = 2x + a - 1
N program sht definuar struktura Delta, n komponentet e s cils, prve variablave a dhe x, paraqitet edhe funksioni Omega.
struct Delta { double a,x; double Omega() { return 2*x+a-1; }; };

int main() { Delta Alfa; double y; cout << "\nVlerat hyrse" << "\n\nVariabla x: "; cin >> Alfa.x; cout << "\nVariabla a: "; cin >> Alfa.a;
y=Alfa.Omega();
cout << "\nVlera e llogaritur y=" << y << "\n\n"; return 0; }
Si shihet nga programi, prmes funksionit Omega:

double Omega() { return 2*x+a-1; };
brenda strukturs Delta, prcaktohet llogaritja e vlers s funksionit y. Meq variablat x dhe a q shfrytzohen n funksion jan variabla t komponenteve t strukturs, brenda kllapave t funksionit nuk sht shnuar asnj parametr. N fillim t programit sht deklaruar variabla Alfa e tipit t strukturs Delta. Kjo variabl shfrytzohet pr qasje te komponentet e zakonshme t strukturs:
Alfa.x Alfa.a
Strukturat 93 si dhe te komponentja me funksionin Omega. Vlera e funksionit y sht llogaritur duke e thirrur funksionin n fjal prmes shprehjes:
y=Alfa.Omega();
Nse ekzekutohet programi i dhn, pr vlerat hyrse t variablave x dhe

a, rezultati do t duket si n Fig.3.23.

struct26
Vlera e funksionit y sht llogaritur n kt mnyr:

y= 2*8+6-1=21
Funksioni, i cili prfshihet brenda strukturs, mund t prmbaj edhe m shum komanda, prkatsisht t definohet plotsisht njlloj si definohen edhe funksionet e zakonshme. Kshtu, p.sh., struktura nga shembulli i msiprm mund t duket:
struct Delta { double a,x; double Omega() { double y; y=2*x+a-1; return y; }; };
Ktu, n kuadr t komponentes n t ciln prfshihet funksioni sht deklaruar variabla ndihmse y, ku ruhet vlera e llogaritur, e cila njkohsisht shnohet n vazhdim t komands return. Nnkuptohet se n vend t variabls

y, gjat definimit t funksionit, mund t shfrytzohet fardo variabl tjetr, pavarsisht se realisht funksioni q definohet sht quajtur si y.
Gjat definimit t funksionit, i cili paraqitet n komponenten e nj strukture, mund t shfrytzohen edhe degzime dhe unaza t ndryshme. Shembull Programi struct27, prmes s cilit llogaritet vlera e funksionit:
h = x + 3 2
n+1
(2i + a)
i=1 (i 4)
N program sht definuar struktura Beta, brenda komponenteve t s cils, prve variablave a, x dhe n, paraqitet edhe funksioni Nata.
// Programi struct27 #include <iostream> using namespace std; struct Beta { double a,x; int n; double Nata() { int i; double h,s=0; for (i=1;i<=(n+1);i++) if (i!=4) s=s+(2*i+a); h=x/2+3*s; return h; }; }; int main() { Beta Dita; double h; cout << "\nVlerat hyrse" << "\n\nVariabla x: "; cin >> Dita.x; cout << "\nVariabla a: "; cin >> Dita.a; cout << "\nVariabla n: "; cin >> Dita.n;
Strukturat 95
h=Dita.Nata();
cout << "\nVlera e llogaritur h=" << h << "\n\n"; return 0; }
Funksioni Nata, i cili sht definuar brenda komponentes s strukturs Beta, shfrytzohet pr prcaktimin e llogaritjes s vlers s variabls h. N funksion shfrytzohen variablat ndihmse i, h dhe s, si dhe unaza e realizuar prmes komands for. Brenda unazs paraqitet edhe komanda if me t ciln pengohet q shums t'i shtohet antari pr i=4, ashtu si sht prcaktuar me shprehjen e dhn t funksionit. N fillim t programit sht deklaruar variabla Dita e tipit t strukturs Beta. Kjo variabl shfrytzohet gjat leximit t vlerave t variablave t komponenteve t strukturs si dhe gjat thirrjes s funksionit Nata pr llogaritjen e vlers s variabls h. Nse ekzekutohet programi i dhn, pr vlerat hyrse, t cilat kompjuterit i jepen prmes tastiers, rezultati n ekran do t duket si n Fig.3.24.

struct27
Nse n programin e dhn m sipr n komponenten e strukturs Beta definohet llogaritja e vetm shums s, e cila paraqitet te funksioni h, struktura do t duket si n vijim.
struct Beta { double a,x; int n; double Nata() { int i; double s=0; for (i=1;i<=(n+1);i++)

if (i!=4) s=s+(2*i+a); return s; };
};
Pas ksaj, vlera e funksionit h do t llogaritet duke e shfrytzuar shprehjen:

h=Dita.x/2+3*Dita.Nata();
Struktura nuk sht e thn t shfrytzohet pr definimin e t gjitha llogaritjeve komplekse q nevojiten gjat zgjidhjes s nj problemi. Shembull Programi structK prmes s cilit llogaritet vlera e funksionit:
3a + (n + 1)! n g = a + 4 (kx + b) 2 k=1 pr x < 0.8 pr x 0.8
N program sht definuar struktura Delta, brenda komponenteve t s cils, prve variablave a, b, x dhe n, paraqitet edhe funksioni Gama prmes s cilit definohet llogaritja vetm e prodhimit.
// Programi structK #include <iostream> using namespace std; struct Delta { double a,b,x; int n; double Gama() { int k; double P=1; for (k=1;k<=n;k++) P=P*(k*x+b); return P; }; }; int main() { Delta Koha; double g;
Strukturat 97
cout << "\nVlerat hyrse" << "\n\nVariabla x: "; cin >> Koha.x; cout << "\nVariabla a: "; cin >> Koha.a; cout << "\nVariabla n: "; cin >> Koha.n; if (Koha.x<0.8) { int i; double F=1;
for (i=1;i<=(Koha.n+1);i++) F=F*i; g=3*Koha.a+F;

} else { cout << "\nVariabla b: "; cin >> Koha.b; g=Koha.a/2+4* Koha.Gama(); } cout << "\nVlera e llogaritur g=" << g << "\n\n"; return 0; }
Ktu, definimi i funksionit g, si dhe llogaritjet e nevojshme kryhen brenda programit. Kurse, prej strukturs shfrytzohet nnprogrami Gama, gjat llogaritjes s vlers s prodhimit, duke e thirrur n shprehjen e funksionit:
g=Koha.a/2+4* Koha.Gama();
Rezultati n ekran, pr vlerat hyrse t cilat kompjuterit i jepen prmes tastiers, do t duket si n Fig.3.25.
98 Programimi i orientuar n objekte Fig.3.25 Pamja e ekranit pas ekzekutimit t programit structK
Komandat pr lexim mund t eliminohen nga programi, nse vlerat e nevojshme pr variablat e veanta kompjuterit i jepen gjat deklarimit t variabls s strukturs, ashtu si shihet n vijim.
Shembull
Versioni structKz i programit structK pr llogaritjen e vlers s funksionit t dhn n detyrn paraprake, por tek i cili variablave u shoqrohen vlerat gjat deklarimit t variabls s strukturs.
// Programi structKz #include <iostream> using namespace std; struct Delta { double a,b,x; int n; double Gama() { int k; double P=1; for (k=1;k<=n;k++) P=P*(k*x+b); return P; }; }; int main() { Delta Koha={4,1,2,3}; double g; if (Koha.x<0.8) { int i; double F=1; for (i=1;i<=(Koha.n+1);i++) F=F*i; g=3*Koha.a+F; }
Strukturat 99
else { g=Koha.a/2+4*Koha.Gama(); } cout << "\nVlera e llogaritur g=" << g << "\n\n"; return 0; }
Nse ekzekutohet programi i dhn, rezultati edhe n kt rast do t jet i njjt me at q u dha n Fig.3.25. Ktu, si sht theksuar edhe m par, vlerat q shnohen brenda kllapave gjat deklarimit t variabls s strukturs duhet t prputhen plotsisht me radhn e shkruarjes s variablave prkatse n struktur. Por, n kt rast nuk ka rndsi pozita e komponenteve me variablat q prfshihen brenda tyre ndaj pozits s funksionit. Kshtu, n programin e dhn, pr strukturn n fjal mund t shfrytzohen edhe versionet vijuese.
a.
struct Delta { double a,b,x; double Gama() { int k=1; double P=1; for (k=1;k<=n;k++) P=P*(k*x+b); return P; }; int n; };
b.
struct Delta { double Gama() { int k=1; double P=1; for (k=1;k<=n;k++) P=P*(k*x+b); return P;

}; double a,b,x; int n; };
N t dy kto raste, deklarimi i variabls s strukturs dhe inicializimi me vlera i variablave n komponentet e strukturs mund t bhet si u dha edhe m sipr:
Delta Koha={4,1,2,3}; meq variablat n struktur vetm e kan ndryshuar pozitn ndaj funksionit Gama, por e kan ruajtur radhn e shkruarjes s tyre.
Definimi jasht strukturs

Funksionet q paraqiten si komponente t strukturs mund t definohen edhe jasht saj, gj q sht me rndsi sidomos kur kemi t bjm me funksione m komplekse. Gjat ksaj, brenda strukturs patjetr vendoset vetm prototipi i funksionit. Me qllim q brenda nnprogramit t shfrytzohen direkt variablat e komponenteve t strukturs (pa ua shtuar emrin e variabls s strukturs dhe pikn), gjat definimit t funksionit, n titullin e tij shnohet edhe emri i strukturs, kshtu:
t e::f();
ku jan:
t - tipi i funksionit. e - emri i strukturs. f - emri i funksionit
Shembull
Programi struct27a si version i programit struct27, prmes s cilit llogaritet vlera e funksionit: n+1 x h = + 3 (2i + a) 2 i=1
(i 4)
N program sht definuar struktura Beta, brenda komponenteve t s cils, prve variablave a, x dhe n, paraqitet edhe funksioni Nata.
// Programi struct27a
Strukturat 101
#include <iostream> using namespace std; struct Beta { double a,x; int n; double Nata(); }; int main() { Beta Dita; double h; cout << "\nVlerat hyrse" << "\n\nVariabla x: "; cin >> Dita.x; cout << "\nVariabla a: "; cin >> Dita.a; cout << "\nVariabla n: "; cin >> Dita.n;
h=Dita.Nata();
cout << "\nVlera e llogaritur h=" << h << "\n\n"; return 0; }
double Beta::Nata() { int i; double h,s=0; for (i=1;i<=(n+1);i++) if (i!=4) s=s+(2*i+a); h=x/2+3*s; return h; };
Ktu, si komponente e strukturs paraqitet edhe prototipi i funksionit:

double Nata();
Njkohsisht, gjat definimit t funksionit, titulli i nnprogramit sht shkruar n formn:
double Beta::Nata()
me ka mundsohet q brenda tij do t prdoren variablat a, x dhe n, t cilat paraqiten n komponentet e strukturs, duke i shkruar si variabla t zakonshme (pa parashtesn dhe pikn). Nse ekzekutohet programi i dhn, rezultati do t duket si n Fig.3.24 t dhn m sipr, pr vlerat hyrse t cilat kompjuterit i jepen prmes tastiers.
Prej funksionit i cili vendoset n komponenten e strukturs mund t mos merret asnj rezultat. Si edhe n rastet e shfrytzimit t funksioneve t zakonshme, para tij duhet t shnohet fjala void. Shembull Programi structD, prmes s cilit llogaritet vlera e funksionit:
2k + a 1 z = k + 3 a 2 k + 2a pr k = 3 pr k = 6 pr k = 9
N program sht definuar struktura Omega, brenda komponenteve t s cils, prve variablave k dhe a sht vendosur edhe prototipi i funksionit Jeta. Ky funksion shfrytzohet pr definimin dhe pastaj edhe pr shtypjen e vlers s funksionit z, nse vlerat e variablave a dhe k kompjuterit i jepen prmes tastiers.
// Programi structD #include <iostream> using namespace std; struct Omega { double a; int k; void Jeta(); }; int main() { Omega Libri;
Strukturat 103
cout << "\nVlera e variabls a: "; cin >> Libri.a; cout << "\nVlera e variabls k: "; cin >> Libri.k;
Libri.Jeta();
return 0; }
void Omega::Jeta() { double z; switch(k) { case 3: z=2*k+a-1; break; case 6: z=k+3*a; break; case 9: z=k*k+2*a; break; default: cout << "\nGabim vlera e variabls k"; goto Fundi; } cout << "\nVlera e llogaritur z=" << z; Fundi: cout << "\n\n"; return; };
Meq prej nnprogramit Jeta nuk merret asnj vler, prkatsisht n vazhdim t komands return t tij nuk shnohet asnj variabl, para titullit t nnprogramit sht shkruar fjala void. Rezultati z, q shtypet n ekran, varet nga vlerat hyrse t cilat kompjuterit i jepen prmes tastiers. Kshtu, p.sh., nse pr variablat a dhe k, t cilat paraqiten n komponentet e strukturs, kompjuterit i jepen vlerat 8 dhe 6, rezultati do t duket si n Fig.3.26.
Fig.3.26 Pamja e ekranit pas ekzekutimit t programit structD, kur vlera e variabls k sht e sakt Por, nse pr k kompjuterit i jepet ndonj vler, e cila nuk sht n grupin e vlerave 3, 6 dhe 9, p.sh., vlera 5, rezultati do t duket si n Fig.3.27.
Fig.3.27 Pamja e ekranit pas ekzekutimit t programit structD, kur vlera e variabls k sht gabim
Funksionet me parametra formal

Nse funksionet q paraqiten n komponentet e strukturave shfrytzojn variabla q nuk prfshihen n struktur, ato duhet t shnohen si parametra formal brenda kllapave, pas emrit t tyre. Si u dha edhe m sipr, definimi i funksioneve t tilla mund t bhet brenda strukturs, ose jasht saj.
Definimi brenda strukturs

Kur funksioni q prfshihet n struktur prmban parametra formal, brenda kllapave n titullin e tij, prve tipeve, shnohen edhe variablat e parametrave formal prkats. Shembull Programi structR prmes s cilit llogaritet vlera e funksionit:
x + 3 g = 2x + (a + 2 b 1)! pr x > z pr x z
N program sht definuar struktura Delta, brenda komponenteve t s cils, prve variablave a dhe b, paraqitet edhe funksioni Gama.
// Programi structR #include <iostream> using namespace std; struct Delta {
Strukturat 105
int a,b; double Gama(double x,double z) { int i; double F,g; if (x>z) g=x+3; else { F=1; for (i=1;i<=(a+2*b-1);i++) F=F*i; g=2*x+F; } return g; }; }; int main() { Delta Jeta; double x,z,g; cout << "\nVlerat hyrse" << "\n\nVariabla x: "; cin >> x; cout << "\nVariabla a: "; cin >> Jeta.a; cout << "\nVariabla b: "; cin >> Jeta.b; cout << "\nVariabla z: "; cin >> z;
g=Jeta.Gama(x,z);
cout << "\nVlera e llogaritur g=" << g << "\n\n"; return 0; }
Funksioni Gama brenda komponentes s strukturs Delta i prmban edhe parametrat formal x e z, si dhe tipet e tyre. Kta dy parametra shfrytzohen gjat llogaritjeve brenda funksionit, por nuk jan variabla t komponenteve t strukturs n fjal. Nga ana tjetr, variablat a dhe b, t cilat shfrytzohen n llogaritje, meq prfshihen n komponentet e strukturs, nuk jan shnuar si parametra formal brenda kllapave t funksionit.
106 Programimi i orientuar n objekte N program, gjat llogaritjes s vlers s funksionit g, sht shfrytzuar shprehja:
g=Jeta.Gama(x,z);
ku vlerat e parametrave aktual x dhe z n program jan shnuar si variabla t zakonshme, sepse ato nuk jan variabla t komponenteve t strukturs. Nse ekzekutohet programi i dhn, rezultati do t duket si n Fig.3.28, pr vlerat hyrse t cilat jan zgjedhur lirisht.

structR
Pr parametrat formal q shfrytzohen gjat definimit t funksioneve q paraqiten si komponente t strukturave, dhe pr parametrat aktual gjat thirrjes s tyre, vlejn principe t ngjashme me ato t funksioneve t zakonshme. Prkatsisht, ato duhet t prputhen pr nga tipi, numri dhe radha e shkruarjes. Funksioni q paraqitet si komponente e strukturs njkohsisht mund t shfrytzoj variabla t komponenteve t strukturs si dhe variabla t tjera jasht saj. Nnkuptohet se brenda kllapave t tij duhet t shnohen vetm variablat t cilat nuk figurojn n komponentet e strukturs. Shembull Programi structA1, prmes s cilit llogariten vlerat e funksioneve:
Strukturat 107
g = ax 2 + bx + c h = 2x + 3 min(x, y, z)
N program sht definuar struktura Alfa, brenda komponenteve t s cils, prve variablave a, b, c dhe x, paraqitet edhe funksioni min prmes s cilit prcaktohet gjetja e vlers minimale mes tri variablave x, y dhe z.
// Programi structA1 #include <iostream> using namespace std; struct Alfa { double a,b,c,x; double min(double y,double z) { double r; if ((x<y) && (x<z)) r=x; else if (y<z) r=y; else r=z;
cout << "\nVlera minimale r=" << r; return r; };

}; int main() { Alfa Jeta={5,2,6,7}; double g,h; g=Jeta.a*Jeta.x*Jeta.x+Jeta.b*Jeta.x+Jeta.c; h=2*Jeta.x+3* Jeta.min(6,4); cout << << << << << return 0; } "\nVlera e funksionit g=" g "\nVlera e funksionit h=" h "\n\n";
108 Programimi i orientuar n objekte N funksionin min, i cili paraqitet si komponente e strukturs, variablat y dhe z jan shnuar brenda kllapave pas emrit t tij, sepse nuk jan variabla t strukturs. Gjithashtu, gjat deklarimit t variabls Jeta t strukturs Alfa:
Alfa Jeta={5,2,6,7};
variablave q paraqiten brenda strukturs u jan shoqruar vlerat: a=5, b=2, c=6 dhe x=7. Ndrkaq gjat thirrjes s funksionit min, n shprehjen:
h=2*Jeta.x+3*Jeta.min(6,4);
parametrave formal y dhe z u jan shoqruar vlerat: y=6 dhe z=4. Rezultati q fitohet n ekran do t duket si n Fig.3.29.

structA1
Mesazhi pr vlern minimale shtypet prmes komands:

cout << "\nVlera minimale r=" << r;
e cila sht vendosur n nnprogram, menjher pasi gjendet vlera minimale mes vlerave t variablave x, y dhe z.
Definimi jasht strukturs

Si u tha edhe m par, funksionet q paraqiten n komponentet e strukturs mund t definohen edhe jasht saj. N at rast, brenda strukturs shnohen prototipet e tyre. Gjat ksaj, si parametra formal brenda kllapave t funksioneve patjetr duhet t shnohen variablat t cilat nuk prfshihen n struktur, ose edhe tipet e tyre, gj q nuk sht e domosdoshme. Shembull Versioni structRb i programit structR, q sht dhn m sipr, prmes s cilit llogaritet vlera e funksionit:
Strukturat 109
x + 3 g = 2x + (a + 2 b 1)! pr x > z pr x z
Ktu, funksioni Gama, i cili paraqitet si komponente e strukturs Delta, definohet jasht strukturs.
// Programi structRb #include <iostream> using namespace std; struct Delta { int a,b; double Gama(double x,double z); }; int main() { Delta Jeta; double x,z,g; cout << "\nVlerat hyrse" << "\n\nVariabla x: "; cin >> x; cout << "\nVariabla a: "; cin >> Jeta.a; cout << "\nVariabla b: "; cin >> Jeta.b; cout << "\nVariabla z: "; cin >> z;
g=Jeta.Gama(x,z);
cout << "\nVlera e llogaritur g=" << g << "\n\n"; return 0; }
double Delta::Gama(double x,double z) { int i; double F,g; if (x>z) g=x+3; else

{ F=1; for (i=1;i<=(a+2*b-1);i++) F=F*i; g=2*x+F; } return g; };
Si shihet nga programi i dhn, si komponente e strukturs paraqitet prototipi i funksionit Gama, i shkruar n formn:
double Gama(double x,double z);
Njkohsisht, funksioni n fjal sht definuar n pjesn e fundit t programit, duke e shnuar titullin e tij n formn:
double Delta::Gama(double x,double z)
Ktu, para titullit t nnprogramit paraqitet edhe emri i strukturs Delta, me ka kompjuteri njoftohet se variablat a dhe b, t cilat shfrytzohen brenda nnprogramit, jan variabla t komponenteve t ksaj strukture. Si zakonisht, prototipi i funksionit mund t shkruhet edhe duke i shnuar brenda kllapave vetm tipet e variablave, pa i shnuar edhe variablat, kshtu:
double Gama(double,double);
Shfrytzimi n struktur i funksioneve t tjera

Te funksionet q paraqiten n komponentet e strukturave mund t shfrytzohen funksione standarde q prfshihen n module t ndryshme t gjuhs programuese C++, ose edhe funksione q definohen pavarsisht nga struktura. Shembull Programi prmes s cilit llogaritet vlera e funksionit:
2 sin(4 x) b g = b x + 3 pr x < a pr x a
duke i deklaruar variablat dhe funksionin n komponentet e strukturs Gama.
Strukturat 111
// Programi struct28 #include <iostream> #include <math.h> using namespace std;
struct Gama { double x,a; int b; double Libri(); };

int main() { double g; Gama Jeta = {0.5,2.3,3}; cout << "\nVlera e variabls x: " << Jeta.x; cout << "\nVlera e variabls a: " << Jeta.a; cout << "\nVlera e variabls b: " << Jeta.b;
g=Jeta.Libri();
cout << "\n\nVlera e funksionit g=" << g << "\n\n"; return 0; }
double Gama::Libri() { double g; if (x<a) g=2*sin(4*x)-b; else g=pow(x,b)+3; return g; };
Llogaritja e vlers s funksionit g sht prcaktuar si komponente e strukturs, prmes funksionit Libri. Brenda funksionit, pr llogaritjen e vlers xb sht shfrytzuar funksioni standard pow, nga moduli math.h, i cili sht shnuar n fillim t programit prmes komands paraprocesorike:
#include <math.h>
Ngjashm shfrytzohet edhe funksioni trigonometrik sin nga moduli n fjal. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket ashtu si sht dhn n Fig.3.30.
Fig.3.30 Pamja e ekranit pas ekzekutimit t programit struct28 Shfrytzimi i funksioneve t definuara jasht strukturs, gjat prcaktimit t funksioneve n komponentet e strukturs, krkon nj kujdes t veant rreth parametrave q nuk paraqiten si variabla t komponenteve t strukturs.
Shembull
Programi structDa, prmes s cilit llogaritet vlera e funksionit:

g = ax + b
i=1 (i 3,4)
(2i + c)
duke i deklaruar variablat a, b dhe x n komponentet e strukturs Alfa. Llogaritja e shums prcaktohet me funksionin Shuma jasht strukturs. Kurse, pr llogaritjen e vlers s funksionit h, shfrytzohet funksioni Gama, i cili vendoset brenda strukturs n fjal.
// Programi structDa #include <iostream> using namespace std;
double Shuma(int n,double c); struct Alfa { double a,b,x; double Gama(int n,double c); };
int main()
Strukturat 113
{ double g;
Alfa R={2,4,3};
cout << "\nT dhnat e cout << "\nVariabla a: << R.a; cout << "\nVariabla b: << R.b; cout << "\nVariabla x: << R.x << "\n"; inicializuara\n"; " " "
g=R.Gama(4,3);
cout << "\nVlera e funksionit g=" << g << "\n\n"; return 0; }
double Alfa::Gama(int n,double c) { double r; r=a*x+b*Shuma(n,c); return r; } double Shuma(int n,double c) { int i; double s=0; for (i=1;i<=n;i++) if (i!=3 && i!=4) s=s+(2*i+c); return s; }
Meq pr llogaritjen e shums nevojiten variablat n dhe c, t cilat nuk paraqiten n komponentet e strukturs, ato figurojn brenda kllapave t funksionit Shuma si variabla t zakonshme. Ashtu shnohen edhe te shprehja:
r=a*x+b*Shuma(n,c);
114 Programimi i orientuar n objekte gjat thirrjes s funksionit n fjal. Kto dy variabla paraqiten si parametra formal edhe te funksioni Gama, i cili sht vendosur si komponente e strukturs, meq brenda ktij funksioni thirret funksioni Shuma. Rezultati q fitohet pas ekzekutimit t programit t dhn do t duket si n Fig.3.31.

structDa
Nse parametrat e funksioneve q nuk i takojn strukturs, por t cilt thirren nga funksionet n komponentet e strukturs, jan variabla t komponenteve t strukturs, nuk duhet t shnohen si parametra formal te funksionet brenda strukturs.
Shembull
Programi structDb, si version i programit structDa, por tek i cili edhe variablat c dhe n merren si komponente t strukturs Alfa.
// Programi structDb #include <iostream> using namespace std; double Shuma(int n,double c);
struct Alfa { double a,b,x,c; int n; double Gama(); };

int main() { double g;
Alfa R={2,4,3,3,4};
Strukturat 115
cout << << << << << << << << << << << << "\nT dhnat e "\nVariabla a: R.a "\nVariabla b: R.b "\nVariabla c: R.c "\nVariabla x: R.x "\nVariabla n: R.n "\n"; inicializuara\n" " " " " "
g=R.Gama();
cout << "\nVlera e funksionit g=" << g << "\n\n"; return 0; }
double Alfa::Gama() { double r; r=a*x+b*Shuma(n,c); return r; }

double Shuma(int n,double c) { int i; double s=0; for (i=1;i<=n;i++) if (i!=3 && i!=4) s=s+(2*i+c); return s; }
Nga analiza e ktij versioni t programit shihet se, meq variablat c dhe n jan prfshir n komponentet e strukturs, te funksioni Gama ato nuk duhet t shnohen si parametra. Prandaj, edhe gjat thirrjes s funksionit n fjal, pr ta llogaritur vlern e funksionit g:
g=R.Gama();
116 Programimi i orientuar n objekte nuk shnohet asnj parametr aktual. Por, meq funksioni Shuma definohet pavarsisht nga struktura, variablat n dhe c duhet patjetr t paraqiten si parametra. Nse ekzekutohet programi i dhn, rezultati do t jet i njjt me at q u dha n Fig.3.31.
Disa funksione brenda strukturs

Brenda nj strukture njkohsisht mund t paraqiten disa komponente me funksione. Definimi dhe shfrytzimi i tyre nuk dallon aspak nga rastet kur struktura prmban vetm nj komponente me funksion. Shembull Programi struct29a, prmes s cilit llogaritet siprfaqja dhe perimetri i katrkndshit knddrejt. Pr llogaritje shfrytzohen funksionet siperfaqja dhe perimetri, t cilt jan komponente t strukturs brinjet.
// Programi struct29a #include <iostream> using namespace std; struct brinjet { double a,b;
double siperfaqja() { return a*b; }; double perimetri() { return 2*a+2*b; };

}; int main() { double s,p; brinjet kater = {6,4};
s=kater.siperfaqja(); p=kater.perimetri();
Strukturat 117
cout << << cout << << cout << << << << << return 0; } "\nVlera e brinjs a: " kater.a; "\nVlera e brinjs b: " kater.b; "\n\nSiprfaqja e katrkndshit s=" s "\nPerimetri i katrkndshit p=" p "\n\n";
N program, brenda strukturs brinjet si komponente paraqiten edhe dy funksione. Me funksionin siperfaqja definohet llogaritja e siprfaqes s katrkndshit, kurse pr llogaritjen e perimetrit t tij sht definuar funksioni perimetri. Meq funksionet jan vendosur si komponente t strukturs, deklarimi i parametrave formal prkats brenda kllapave sht i panevojshm. Funksionet n fjal brenda programit thirren duke i shfrytzuar shprehjet:
s=kater.siperfaqja(); p=kater.perimetri();
Fig.3.32 Pamja e ekranit pas ekzekutimit t programit struct29a Funksionet q deklarohen si komponente t strukturs mund t prmbajn edhe m shum komanda. Kshtu, struktura n programin struct29a mund t deklarohet:
struct brinjet { double a,b; double siperfaqja() { double s; s=a*b; return s;

}; double perimetri() { double p; p=2*a+2*b; return p; };
};
Brenda funksioneve, t cilat paraqiten si komponente t funksioneve q prfshihen n struktur, prmes komandave:
double s;
dhe
double p;
variablat s dhe p jan deklaruar si variabla lokale dhe, si t tilla, mund t shfrytzohen vetm brenda nnprogrameve. Edhe n rastet kur si komponente t strukturave paraqiten dy e m shum funksione, definimi i tyre mund t bhet jasht strukturs. Kshtu, programi i dhn m sipr, me ndryshimet e prmendura, do t duket si n vijim.
struct brinjet { double a,b; double siperfaqja(); double perimetri(); };

int main() { double s,p; brinjet kater = {6,4}; s=kater.siperfaqja(); p=kater.perimetri(); cout << "\nVlera e brinjs a: " << kater.a; cout << "\nVlera e brinjs b: " << kater.b;
Strukturat 119
cout << << << << << return 0; } "\n\nSiprfaqja e katrkndshit s=" s "\nPerimetri i katrkndshit p=" p "\n\n";
double brinjet::siperfaqja() { double s; s=a*b; return s; }; double brinjet::perimetri() { double p; p=2*a+2*b; return p; };
Nse ekzekutohet programi i dhn, rezultati nuk do t dallohet nga ai q u dha m sipr.
Disa struktura brenda funksioneve

Funksionet q paraqiten si komponente t strukturs, prve variablave t komponenteve t strukturs, gjat llogaritjeve mund t shfrytzojn edhe variabla t komponenteve t strukturave t tjera q definohen n program. Kto variabla, te prototipi i funksionit duhet t deklarohen si parametra formal t tipeve prkatse. Kurse, gjat thirrjes s funksioneve n programin kryesor, parametrat formal zvendsohen me variablat e komponenteve t strukturave t tjera. Shembull Programi structF1 prmes s cilit llogaritet vlera e funksionit:
2 pr a < b ax + bx + c g = pr a b ax + 3c d ku variablat a, b dhe c vendosen te komponentet e strukturs Alfa, kurse variablat x dhe d - te komponentet e strukturs Beta. Pr llogaritjen e vlers s funksionit g shfrytzohet funksioni Gama, i cili paraqitet si komponente e strukturs Alfa.
// Programi structF1

#include <iostream> using namespace std;
struct Alfa { double a,b,c; double Gama(double x,double d); }; struct Beta { double x,d; };
int main() { double g;
Alfa Dita = {1,2,3}; Beta Nata={4,5};

cout << << << << << << << << << << << "\nVlerat e variablave" "\n\nVariabla a: " Dita.a "\nVariabla b: " Dita.b "\nVariabla c: " Dita.c "\nVariabla x: " Nata.x "\nVariabla d: " Nata.d;
g=Dita.Gama(Nata.x,Nata.d);
cout << "\n\nVlera e funksionit g=" << g << "\n\n"; return 0; }
double Alfa::Gama(double x,double d) { double g; if (a<b) g=a*x*x+b*x+c; else g=a*x+3*c-d;
Strukturat 121
return g; };
Ktu, te prototipi i funksionit:

double Gama(double x,double d);
si parametra formal t zakonshm jan shnuar emrat e variablave x dhe d, t cilat prfshihen n komponentet e strukturs Beta. Pastaj, gjat thirrjes s funksionit Gama, pr ta llogaritur vlern e funksionit g:
g=Dita.Gama(Nata.x,Nata.d);
si parametra aktual jan shfrytzuar variablat e komponenteve t strukturs Beta. Nse ekzekutohet programi i dhn, rezultati do t duket si n Fig.3.33.

structF1
Vlera e funksionit sht llogaritur me shprehjen:

g = ax 2 + bx + c
sepse a<b, gj q shihet edhe nga rezultati. Nnkuptohet se funksioni q paraqitet n komponenten e njrs struktur, prve variablave t komponenteve t strukturs tjetr, mund t shfrytzoj edhe
122 Programimi i orientuar n objekte vlera t variablave t zakonshme. Pr kt qllim, te prototipi i funksionit variablat duhet t shnohen si parametra formal. Shembull Programi structF2, prmes s cilit tabelohen vlerat e funksioneve:
y = a sin(bx) c z = ln(ex) d
pr vlera t ndryshme t variabls x, mes vlers fillestare 1 dhe vlers prfundimtare 5, duke e ndryshuar at me hapin 0.5. N program jan definuar strukturat Ro dhe Fi. N komponentet e strukturs Ro, prve variablave a, b dhe x, paraqiten edhe funksionet FunkY dhe FunkZ. Kurse, struktura Fi n komponentet e saj i prfshin vetm variablat c dhe d.
// Programi structF2 #include <iostream> #include <iomanip> #include <math.h> using namespace std;
struct Ro { double a,b,x; double FunkY(); double FunkZ(double c,double d,double e); }; struct Fi { double c,d; };
int main() { double e=3,y,z; char g[]="-----------------------";
Ro R = {2,5}; Fi F={6,4};
cout << << << << "\nVlerat e variablave" "\n\nVariabla a: " R.a "\nVariabla b: "
Strukturat 123
<< << << << << << << << R.b "\nVariabla c: " F.c "\nVariabla d: " F.d "\nVariabla e: " e "\n\n"; z"
cout << " x y << "\n" << g << "\n"; for (R.x=1;R.x<=5;R.x=R.x+0.5) { y=R.FunkY(); z=R.FunkZ(F.c,F.d,e); cout << << << << << << << << fixed setprecision(2) setw(6) R.x setw(8) y setw(8) z
<< "\n"; } cout << g << "\n\n"; return 0; }
double Ro::FunkY() { double y; y=a*sin(b*x); return y; }; double Ro::FunkZ(double c,double d,double e) { double z; z=c/d*log(e*x); return z; };
124 Programimi i orientuar n objekte Funksioni FunkY nuk ka asnj parametr, meq variablat n shprehjen e funksionit y, q definohen prmes tij, bjn pjes n komponentet e strukturs Ro, ku edhe funksioni paraqitet n njrn prej komponenteve t saj. Brenda kllapave t funksionit FunkZ paraqiten 3 parametra formal, t cilt marrin pjes n llogaritjen e vlers s funksionit z, por nuk jan variabla n komponentet e strukturs Ro. Meq variablat c dhe d t funksionit z prfshihen n komponentet e strukturs Fi, gjat thirrjes s funksionit FunkY n program, ato zvendsohen me parametrat aktual F.c dhe F.d:
z=R.FunkZ(F.c,F.d,e);
pasi variabla F sht deklaruar e tipit t strukturs Fi. Ktu, vlerat e funksioneve y dhe z llogariten dhe shtypen brenda unazs s variabls x. Si rezultat n ekran fitohet tabela e cila shihet n Fig.3.34, pr vlera t ndryshme t variabls x q prfshihet n komponenten e strukturs Ro (shkruhet si F.x, sepse variabla F sht e tipit t ksaj strukture).

structF2
Strukturat 125
Fushat n struktura
N komponentet e strukturave mund t vendosen edhe fusha, p.sh., si jan vektort. Rezervimi i vendeve t nevojshme pr fushat (numri maksimal i mundshm i vendeve) bhet prmes deklarimit si konstante para definimit t strukturave. Por, njkohsisht brenda strukturave, n komponente t veanta vendosen variablat n t cilat ruhen dimensionet aktuale t fushave. Shembull Programi structV1 prmes s cilit gjendet antari maksimal n vektorin e dhn A(n), i cili sht vendosur n komponenten e strukturs Vektori.
// Programi structV1 #include <iostream> #include <iomanip> using namespace std;
const int m=10; struct Vektori { int n; double A[m]; };

int main() { int i; double x; char g[]="----------------";
Vektori Vlera = {5,2.7,4.1,3.5,12.6,8.3};

cout << << << << "\nAntart e vektorit\n" "\n i A[i]\n" g "\n";
for (i=0;i<Vlera.n;i++) cout << setw(4) << i << setw(10) << Vlera.A[i] << "\n"; cout << g

<< "\n";
x=Vlera.A[0]; for (i=1;i<Vlera.n;i++) if (Vlera.A[i]>x) x=Vlera.A[i];

cout << "\nVlera maksimale x=" << x << "\n\n"; return 0; }
N komponenten e par t strukturs Vektori sht vendosur variabla n, n t ciln do t ruhet numri aktual i antarve t vektorit, i cili shfrytzohet n program. Kurse n komponenten e dyt t tij prfshihet vektori A me m-antar, ku m e paraqet numrin maksimal t mundshm t tij, i cili numr ktu sht deklaruar paraprakisht si konstante me vler 10. Gjat deklarimit t variabs Vlera t strukturs Vektori:
Vektori Vlera = { 5,2.7,4.1,3.5,12.6,8.3};
bhet inicializimi me vlera, s pari i variabls n (numri i par 5) dhe pastaj edhe i antarve t vektorit A. N program, prmes unazs s par for shtypen antart e vektorit, duke i shkruar n formn Vlera.A[i]. Kjo form e shkruarjes shfrytzohet edhe m posht, gjat gjetjes s antarit maksimal, duke e zbatuar algoritmin e zakonshm pr gjetje t antarit t caktuar n vektor. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket ashtu si shihet n Fig.3.35.

structV1
Gjat operimit me antart e fushave, brenda strukturs mund t shfrytzohen edhe funksione.
Strukturat 127
Shembull
Programi structV2, si version i programit structV1, tek i cili pr gjetjen e antarit maksimal x t vektorit A(n) shfrytzohet funksioni Max, q vendoset n komponenten e strukturs Vektori.
// Programi structV2 #include <iostream> #include <iomanip> using namespace std; const int m=10;
struct Vektori { int n; double A[m]; double Max(); };

int main() { int i; Vektori cout << << <<
Vlera = {5,2.7,4.1,3.5,12.6,8.3}; "\nAntart e vektorit\n" "\n i A[i]" "\n-------------------\n";
for (i=0;i<Vlera.n;i++) cout << setw(4) << i << setw(10) << Vlera.A[i] << "\n"; cout << "-------------------\n" << "\nVlera maksimale x: " << Vlera.Max() << "\n\n"; return 0; } double Vektori::Max() { double x=A[0]; int i; for (i=1;i<n;i++)

if (A[i]>x) x=A[i]; return x; };
Pr gjetjen e antarit maksimal x brenda vektorit A(n) prmes funksionit Max, ktu sht shfrytzuar procedura e zakonshme, ashtu si shpjegohet n vijim.
Prmes deklarimit x=A[0], si vler fillestare pr antarin maksimal merret antari i par i vektorit. Duke i krahasuar t gjith antart e vektorit, sa her q gjendet se nj antar sht m i madh se vlera aktuale e variabls x, prmes shprehjes:
x=A[i];
te variabla x ruhet vlera e re maksimale.
N fund, vlera maksimale brenda vektorit sht vlera q ruhet te variabla x.
Nse ekzekutohet programi i dhn, rezultati n ekran do t jet i njjt me at q u dha n Fig.3.35.
Fushat e strukturave
Ngjashm si fushat e zakonshme, mund t krijohen edhe fusha t strukturave. Gjat ksaj, n nj element t fushs prfshihen t dhnat e t gjitha komponenteve prkatse t strukturs. Shembull Programi structFS1, prmes s cilit tregohet deklarimi si vektor me n-antar i strukturs studenti, e cila sht e tipit person.
// Programi structFS1 #include <iostream> #include <iomanip> using namespace std;
struct person { char emri[8],qyteti[10];
Strukturat 129
int viti; };
int main() { const int n=3; int i;
person studenti[n];
cout << "\nT dhnat nga tastiera\n\n"; for (i=0;i<n;i++) { cout << "Emri .....: "; cin >> studenti[i].emri; cout << "Qyteti ...: "; cin >> studenti[i].qyteti; cout << "Viti .....: "; cin >> studenti[i].viti; cout << "\n"; } cout << "\nT dhnat e lexuara\n\n" << " Emri Qyteti Viti" << "\n-----------------------------\n" << right;
for (i=0;i<n;i++) { cout << setw(8) << studenti[i].emri; cout << setw(13) << studenti[i].qyteti; cout << setw(7) << studenti[i].viti << "\n"; } cout << "-----------------------------" << "\n\n"; return 0; }
N fillim t programit sht definuar struktura person, me komponentet t cilat i prmbajn variablat emri, vendi dhe viti. Pastaj, prmes komands:
person studenti[n];
130 Programimi i orientuar n objekte variabla e strukturs person deklarohet si vektor studenti. Si rezultat, do antar i vektorit prmban 3 t dhna, emrin e studentit, vendin dhe vitin e lindjes. N kt mnyr, nse t dhnat e regjistruara vrehen nga jasht, ato do t mund t vendoseshin n nj matric me n-rreshta dhe 3-kolona. Pr qasje n variablat e komponenteve t veanta t strukturs studenti, pr antarin e i-t t vektorit, ato shkruhen n formn:
studenti[i].vendi studenti[i].qyteti studenti[i].viti
Nse ekzekutohet programi i dhn dhe prmes tastiers kompjuterit i jepen t dhnat e krkuara pr 3 student (meq n=3), n ekran do ta kemi pamjen e dhn n Fig.3.36.
Fig.3.36
Strukturat 131 Pamja e ekranit pas ekzekutimit t programit structFS1
Variablat e prfshira n komponentet e strukturs q sht deklaruar si fush mund t inicializohen direkt n program. Shembull Programi structFS2, prmes s cilit tregohet inicializimi direkt i variablave t strukturs java, e cila sht deklaruar si vektor i tipit dita.
// Programi structFS2 #include <iostream> #include <iomanip> using namespace std;
struct dita { int nr; double temp; };

int main() { int i; double s;
dita java[7]={1,10.5, 2,12.7, 3,15.4, 4,11.8, 5,12.3, 6,13.9, 7,12.5};

cout << "\nT dhnat e strukturs java\n" << "\n Dita Temperatura\n" << "---------------------\n"; for (i=0;i<7;i++) { cout << setw(4) << java[i].nr << " " << setw(10) << java[i].temp

<< "\n"; } cout << "---------------------" << "\n\n"; s=0; for (i=0;i<7;i++) s=s+java[i].temp; cout << "Temperatura mesatare: " << s/7 << "\n\n"; return 0; }
Ktu, pas deklarimit si vektor t strukturs java e tipit dita, ajo sht inicializuar me vlera, plotsisht njlloj si do t inicializohej matrica me 7-rreshta dhe dy kolona. Kolona e par i prgjigjet variabls nr, kurse n kolonn e dyt prfshihen vlerat e temperaturave ditore temp. Pas inicializimit, t dhnat e temperaturave javore shtypen si tabel, duke i shkruar komponentet e strukturs n formn:
java[i].nr java[i].temp
N fund, prmes unazs for, llogaritet shuma s e temperaturave t 7 ditve t javs dhe shtypet e pjestuar me 7, ashtu q t fitohet temperatura mesatare javore. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.3.37.
Fig.3.37 Pamja e ekranit pas ekzekutimit t programit structFS2
Strukturat 133
N vend t detyrave me siprfaqe dhe perimetr t merren det. me shuma dhe det. tjera m serioze. Korrigjimet t bhen pr libr. =================== Ndoshta t fshihet =============== Shembull: struktura q e kam marr prej shembullit class1. Meq te funksioni nuk kam shnuar parametra, kjo e nnkupton se shfrytzohen variablat e strukturs. Kompjuteri njohtimin e merr edhe prej Nata::Maksimale().
// Programi structF #include <iostream> using namespace std; struct Nata { double Maksimale(); double a,b,c; }; int main() { Nata Vlera={7.4,14.2,9.6}; double z; z=Vlera.Maksimale(); cout << z; return 0; } double Nata::Maksimale() { double g; if ((a>b) && (a>c)) g=a; else if (b>c) g=b; else g=c; return g; }
Unazat mund t shfrytzohen prej fillimit!!! 17-545 Strukturat e ndrthurura 17-551 f128 Programmers Notebook
Strukturat 135 Strukturat si parametra t funksioneve 17-546 f.398 Pascal, f.540 Malik. Strukturat dhe unionet f214 Practical C++ Programer's Notebook f114 Struktura mund t prmbaj edhe variabla t tipeve q prcaktohen nga vet shfrytzuesi (p.sh. var. t numruara Daitel f406 17-540 Variablat e strukturs (Daitel nuk e shfrytzon si objekt) Komponentet e strukturs Variablat e komponenteve t strukturs Me deklarimin formohet kopja ose instanca e strukturs. - versioni kur te nj funksion shfrytzohen disa struktura (njra sht struktur ku sht prfshir funksioni) - te dy funksione shfrytzohen dy struktura (njra sht struktur ku sht prfshir funksioni). - n t dy rastet me parametra formal t variablave jasht strukturs. Fushat n struktura: 17-547 Fushat e strukturave: 11-220 Konstruktort duhet t vlejn edhe pr strukturat. -----------------------------------------------------------------------------------Vlerat e variablave t cilat brenda strukturs jan deklaruar si private, mund t merren edhe prmes referencs (operatori &). Kjo ka rndsi sidomos kur nevojitet q prmes nj funksioni prej komponenteve t strukturs t merren vlerat e disa variablave. Shih te klasat dhe te pointert. 17-300 Edhe te strukturat kjo ka rndsi sepse parmetrat aktual nuk do ta ken pikn. N ribotim t jepet nj shembull me referenca edhe te strukturat. ----------------------------------------------------------------
3
Klasat
Definimi i klasave t zakonshme Deklarimi i objekteve Qasja te komponentet e klass Forma e prgjithshme e klasave Definimi i funksioneve jasht klass Forma t tjera t inicializimit t variablave Shfrytzimi i vlerave t variablave private Llogaritjet me variablat e klass Shfrytzimi i funksioneve brenda klass Konstruktort Destruktort Trashgimia Operatori i shoqrimit tek objektet Krahasimi i variablave t klass Fushat brenda klasave Fushat e objekteve Dukshmria e klasave dhe e objekteve 134 136 137 139 143 145 149 153 164 172 188 191 204 206 212 214 217
Kur flitet pr programimin e orientuar n objekte (ang. object-oriented programming), ose shkurt - programimin me objekte, gjithnj mendohet n klasat si dhe n objektet q deklarohen me shfrytzimin e tyre. Klasat paraqesin nj tip tjetr t strukturave, n t cilat bashkrisht vendosen t dhnat dhe funksionet q i shfrytzojn ato t dhna. Por, n gjuhn C++, strukturat dhe klasat kan nj dallim t vogl. Derisa qasja e nnkuptuar (ang. default access) te strukturat sht publike (ang. public), te klasat kjo qasje e nnkuptuar sht private (ang. private), gj q do t shpjegohet n pjest vijuese. Prmes klasave jepet nj mundsi e shkruarjes s programeve, t cilt sipas nevojs, leht ndryshohen, duke i ndryshuar vetm klasat. Gjat ksaj, problemi q zgjidhet coptohet n klasa dhe n deklarimin e objekteve prkatse, gj q ka nj rndsi t veant kur kemi t bjm me programe komplekse, me ka zvoglohet mundsia e gabimeve. Programimi i zakonshm, n t cilin shfrytzohen vetm funksionet, ndryshe quhet edhe programim procedural . Prmes programimit me objekte, m leht modelohet bota reale, krahasuar me programimin procedural, meq brenda objekteve prfshihen funksionet dhe t dhnat t cilat ato i shfrytzojn. N fillim t pjess vijuese, me qllim t krahasimit t strukturave dhe t klasave, do t shfrytzohen shembujt e programeve elementare, t cilt jan marr gjat shpjegimit t strukturave.
Definimi i klasave t zakonshme

T gjitha format e definimit t strukturave vlejn edhe pr definimin e klasave t zakonshme. Kshtu, p.sh., le ta marrim strukturn e cila n form t prgjithshme duket si n vijim:
struct e { t1 x1; t2 x2; ...... tn xn; };
Klasat 135 ku jan:

e - emri i strukturs. t1, t2, , tn - tipet e t dhnave n komponentet e strukturs. x1, x2, , xn - variablat n komponentet e strukturs.
Definimi i strukturs s dhn si klas do t bhet:

class e { public: t1 x1; t2 x2; ...... tn xn; };
ku jan:
e - emri i klass. t1, t2, , tn - tipet e t dhnave n komponentet e klass. x1, x2, , xn - variablat n komponentet e klass.
Nse krahasohet forma e prgjithshme e klass me formn e prgjthshme t strukturs, q u dhan m sipr, qart shihet se: n vend t fjals struct, ktu sht shfrytzuar fjala class dhe para komponenteve t klass sht shnuar fjala public.
Me fjaln public t shnuar para komponenteve t klass, atyre mund t'u qasemi dhe t'i shfrytzojm n program. Fjala public, e cila njihet si specifikuesit e qasjes (ang. access specifier), nuk shfrytzohej te struktura, sepse, si u tha edhe n fillim, qasja e till te struktura sht e nnkuptuar, prkatsisht struktura sht klas me qasje publike. Kurse, nse te klasa nuk shfrytzohet specifikuesi public, ai do t nnkuptohet nga kompjuteri si private, dhe qasja direkte nga jasht sht e pamundshme. Shembull Programi class1, n t cilin sht definuar klasa person, ku prfshihen t dhnat e tipeve t ndryshme t nj personi, si jan emri, viti i lindjes dhe qyteti i banimit.
// Programi class1 #include <iostream> using namespace std; class person { public: char emri[8]; char qyteti[10]; int viti; }; int main() { }
Shembulli i programit t dhn sht i ngjashm me programin struct1, i shfrytzuar gjat shpjegimit t definimit t strukturave. Nse krahasohet programi class1 me programin struct1, si u tha edhe m sipr, para komponenteve t klass sht shtuar fjala public:. Meq n trupin e programit t dhn nuk prfshihen komanda, me ekzekutimin e tij nuk do t merret asnj rezultat.
Deklarimi i objekteve
Pas definimit t nj klase kompjuteri nuk rezervon vende n memorie pr komponentet q prfshihen brenda klass, pavarsisht se deklarohen tipet e variablave prkatse. Por, me klasn krijohet nj tip i ri, i cili pastaj mund t shfrytzohet pr deklarimin e objekteve t asaj klase. Definimi i klass tregon vetm se si objekti duket, kurse pas deklarimit n program, krijohet objekti i klass, ose, si thuhet, krijohet instanca e klass. Deklarimi i objekteve t klass bhet plotsisht njlloj si deklarohen variablat e strukturave, ose edhe variablat e tipeve t zakonshme. Por, ktu, n vend t variabls deklarohet nj objekt. N form t prgjithshme ky deklarim duket: e o; ku jan:
e - emri i klass. o - objekti i tipit t klass e.
Klasat 137
Shembull
Programi class2, n t cilin shihet definimi i klass person dhe shfrytzimi i saj pr deklarimin e objektit studenti t tipit t klass person.
// Programi class2 #include <iostream> using namespace std; class person { public: char emri[8],qyteti[10]; int viti; }; int main() { person studenti; }
Ktu, prmes shprehjes:

person studenti;
deklarohet objekti studenti i klass person, i cili n fakt paraqet nj kopje t klass q sht definuar m par. Pas ktij deklarimi, n memorien e kompjuterit rezervohen vende pr variablat t cilat paraqiten n komponentet e klass. Nse ekzekutohet programi i dhn, meq n trupin e tij deklarohet dhe nuk shfrytzohet objekti studenti, kompjuteri do t gjeneroj nj mesazh pr t na njoftuar se studenti sht variabl lokale q nuk i referohemi (q nuk shfrytzohet).
Qasja te komponentet e klass

Komponenteve t klass mund t'u qasemi pasi t jet deklaruar objekti prkats. Pr qasje n komponente t klass shfrytzohen shprehjet e forms:
o.x
ku jan:
o - objekti i deklaruar i klass.

x - variabla ose funksioni n komponenten e klass. . - operatori pik (ang. dot operator) pr qasje variabls ose funksionit t
komponentes s klass. Shembull Programi class3, prmes s cilit tregohet qasja te komponentet e klass person.
// Programi class3 #include <iostream> using namespace std; class person { public: char emri[8],qyteti[10]; int viti; }; int main() { person studenti; cout << "\nT dhnat nga tastiera\n\n"; cout << "Emri .....: "; cin >> studenti.emri ; cout << "Qyteti ...: "; cin >> studenti.qyteti ; cout << "Viti .....: "; cin >> studenti.viti ; cout << "\n\nT dhnat e lexuara\n"; cout << "\nEmri .....: " << studenti.emri ; cout << "\nQyteti ...: " << studenti.qyteti ; cout << "\nViti .....: " << studenti.viti << "\n\n"; return 0; }
N program, si edhe te strukturat, tri variablave t prfshira n objektin

studenti, i cili sht deklaruar i klass person, u qasemi duke i shnuar ato
n format:
studenti.emri studenti.qyteti
Klasat 139
studenti.viti
Nse ekzekutohet programi i dhn dhe pas mesazheve prkatse, prmes tastiers kompjuterit i jepen vlerat hyrse Valmira, Ohri dhe 1983, n ekran do ta kemi pamjen e cila shihet n Fig.4.1.

class3
Forma e prgjithshme e klasave

Zakonisht, kur flitet pr klasat, nnkuptohet se komponentet e tyre prmbajn variabla dhe funksione t tipeve t caktuara. Specifikuesit e qasjes s tyre, prve public, q u shpjegua m sipr, mund t jen edhe private ose protected. Ktu, fillimisht, do t flitet pr dy tipet e para t specifikuesve, kurse pr specifikuesin protected do t bhet fjal m von. Forma e prgjithshme e definimit t klass mund t duket:
class e { private: t1 y1; t2 y2; ...... tn yn; public: tp zp; tq zq; ...... ts zs; };
ku jan:
e - emri i klass. t1, t2, , ts - tipet e variablave ose t funksioneve n komponentet e
klass.
y1, y2, , yn - variablat ose funksionet n komponentet e klass, t
deklaruara si publike.
zp, zq, , zs - variablat ose funksionet n komponentet e klass, t
deklaruara si private. Radha e shkruarjes s specifikuesve t qasjes brenda definicionit t klass nuk ka rndsi, si dhe specifikuesit e veant mund t shfrytzohen edhe disa her, gj q nuk sht e nevojshme. Variablat e tipeve t caktuara q prfshihen n klas, njihen si komponente t dhnash (ang. data components), ose antar t dhnash (ang. data members). Kurse funksionet q prfshihen n klas njihen si komponente funksionesh (ang. function components), ose antar funksionesh (ang. member functions), ose edhe metoda (ang. methods). T gjitha komponentet ose antart brenda klass me nj fjal mund t quhen komponente t klass (ang. class components), ose antar t klass (ang. class members). Zakonisht, komponentet me t dhna deklarohen si private, kurse komponentet e funksioneve - si publike. Por, kjo nuk sht e thn, sepse brenda klasave njkohsisht mund t deklarohen funksione dhe variabla private dhe publike. Deklarimi i komponenteve t klass si private nuk ka t bj me at se t dhnat jan sekrete dhe si t tilla nuk duhet t shihen nga t tjert. Por, kjo lidhet me pengimin e shfrytzimit direkt t tyre me qllim t eliminimit t gabimeve t mundshme gjat shkruarjes s programeve t gjata. Komponentet, t cilat brenda klass deklarohen si private, nuk mund t'u qasemi direkt nga jasht. Ato mund t shfrytzohen direkt vetm brenda funksioneve t klass, pavarsisht se a kemi t bjm me funksione private ose publike. Kurse qasja te komponentet q deklarohen si publike sht e lir, si brenda klass ashtu edhe n program. Shembull Programi class4a, prmes s cilit definohet klasa Jeta, n komponentet e s cils paraqiten variablat m dhe a, njra e deklaruar si private, kurse tjetra - si publike, si dhe funksionet vlera dhe shtypja t deklaruara si publike.
Klasat 141
// Programi class4a #include <iostream> using namespace std; class Jeta { private: int m; public: double a; void vlera(int k) { m=k; } void shtypja() { cout << "\nVlera e variabls private m=" << m << "\n"; } }; int main() { Jeta Dita; Dita.vlera(77); cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a; Dita.shtypja(); cout << "\nVlera e variabls publike a=" << Dita.a << "\n\n"; return 0; }
Meq variabla m sht deklaruar si variabl private, asaj nuk mund t'i qasemi direkt nga jasht. Prandaj, pr ta inicializuar at me nj vler shfrytzohet funksioni vlera, me parametrin formal k, t cilin mund ta shfrytzojm nga jasht sepse sht deklaruar si funksion publik. Brenda funksionit paraqitet shprehja m=k, prmes s cils vlera e variabls k vendoset te variabla m.
142 Programimi i orientuar n objekte Nga ana tjetr, variabla a dhe funksionet vlera dhe shtypja jan deklaruar si publike, gj q e nnkupton se atyre mund t'u qasemi direkt nga jasht, prkatsisht nga programi. N fillim t programit kryesor, prmes komands:
Jeta Dita;
deklarohet objekti Dita i klass Jeta. Pastaj, duke e thirrur funksionin vlera:
Dita.vlera(77);
ku n vend t parametrit formal k sht shnuar parametri aktual 77, variabls m i shoqrohet kjo vler. Kurse, prmes komandave:
cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a;
lexohet vlera e variabls a, e cila brenda klass sht deklaruar si publike, vler t ciln kompjuterit duhet t'ia japim prmes tastiers. Pr shtypje t vlers s variabls m, meq nuk mund t'i qasemi direkt, sepse sht deklaruar si private, shfrytzohet funksioni shtypja, i cili sht deklaruar si funksion publik, duke e thirrur kshtu:
Dita.shtypja();
Funksioni shtypja ka qasje te variabla m, pavarsisht se ajo sht deklaruar si private, sepse ai gjendet n njrn nga komponentet e klass. N fund t programit, pr shtypje t vlers s variabls a, lirisht sht shfrytzuar komanda:
cout << "\nVlera e variabls publike a=" << Dita.a << "\n\n";
sepse n t kemi qasje direkte pr shkak t deklarimit t saj si publike. Nse, p.sh., prmes tastiers kompjuterit pr variabln a ia japim vlern hyrse 44.56, n ekran do ta kemi pamjen e dhn n Fig.4.2.
Fig.4.2
Klasat 143 Pamja e ekranit pas ekzekutimit t programit class4a Funksioni shtypja mund t shfrytzohet edhe pr shtypjen e vlers s variabls a, ashtu si sht dhn n vijim n verzionin class4b t programit.
// Programi class4b #include <iostream> using namespace std; class Jeta { private: int m; public: double a; void vlera(int k) { m=k; } void shtypja() { cout << "\nVlera e variabls private m=" << m << "\n\nVlera e variabls publike a=" << a << "\n\n"; } }; int main() { Jeta Dita; Dita.vlera(77); cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a; Dita.shtypja(); return 0; }
Nse ekzekutohet ky version i programit, pr vler hyrse t njjt, rezultati n ekran do t duket si ai q u dha n Fig.4.2. Forma e prgjithshme e dhn m sipr pr definimin e klasave, plotsisht njlloj mund t shfrytzohet edhe te strukturat, prfshir edhe specifikuesit e qasjes public, private dhe protected.
Definimi i funksioneve jasht klass

Si u shpjegua te strukturat, edhe te klasat funksionet mund t definohen jasht trupit t klasave. Por, brenda definicionit t tyre duhet t shnohen prototipet e funksioneve. Shembull Programi class4c si version i programit class4b, tek i cili brenda klass Jeta jan deklaruar vetm prototipet e funksioneve vlera dhe shtypja, kurse definimi i tyre sht br jasht definicionit t klass.
// Programi class4c #include <iostream> using namespace std; class Jeta { private: int m; public: double a; void vlera(int k); void shtypja(); }; int main() { Jeta Dita; Dita.vlera(77); cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a; Dita.shtypja(); return 0; } void Jeta::vlera(int k) { m=k; } void Jeta::shtypja() { cout << "\nVlera e variabls private m=" << m << "\n\nVlera e variabls publike a=" << a
Klasat 145
<< "\n\n"; }
Nga definicionet e funksioneve shihet se, plotsisht njlloj si edhe te funksionet q prfshihen n struktura, para emrave t tyre shnohet edhe emri Jeta i klass, i shoqruar me operatorin pr zbrthim t dukjes (ang. scope resolutin operator), q shnohet me katr pika (::). Kjo form e shkruarjes s funksioneve jasht definicionit t klass, sidomos kur funksionet prmbajn m shum komanda, sht m praktike pr shkak t dukshmris m t mir t definicionit t klass. Funksionet q prfshihen brenda klasave mund t jen edhe t tipit inline. Kshtu, p.sh., nse funksioni vlera te programi i fundit class4c merret i tipit inline, prototipi i tij brenda definicionit t klass Jeta duhet t shkruhet n formn:
inline void vlerat(int k,double x);
Gjithashtu, titulli prkats gjat definimit t funksionit duhet t shkruhet:

inline void Jeta::vlerat(int k,double x)
Shfrytzimi i funksioneve t tipit inline lidhet me rritjen e shpejtsis s ekzekutimit t tyre. Por, gjat ksaj rritet edhe programi, sepse, kur thirren funksionet e ktij tipi, ato bhen pjes e programit.
Forma t tjera t inicializimit t variablave

Pr inicializimin e variablave q paraqiten si antar t klass mund t shfrytzohen edhe mnyra t tjera. Njra mnyr sht ajo e leximit nga jasht t vlerave t tyre, duke definuar brenda klasave funksione me komanda pr lexim. Por, nse variablat vendosen vetm n pjesn publike t klasave, inicializimi i tyre mund t bhet edhe gjat deklarimit t objekteve.
Inicializimi prmes leximit

Nj mnyr tjetr e inicializimit t variablave, n veanti atyre t deklaruara si private, prve asaj q u shfrytzua m sipr, sht ajo e leximit t vlerave t tyre. Pr kt qllim, komandat pr lexim duhet t prfshihen n funksionin e veant brenda klass, duke e deklaruar ate si funksion publik. Shembull Programi class5a si version i programit class4c, tek i cili brenda klass Jeta sht definuar funksioni leximi si publik, prmes s cilit lexohet vlera e variabls private m.
// Programi class5a #include <iostream> using namespace std; class Jeta { private: int m; public: double a; void leximi(); void shtypja(); }; int main() { Jeta Dita; Dita.leximi(); cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a; Dita.shtypja(); return 0; } void Jeta::leximi() { cout << "\nLeximi i vlers s variabls m: "; cin >> m; } void Jeta::shtypja() { cout << "\nVlera e variabls private m=" << m << "\n\nVlera e variabls publike a=" << a << "\n\n"; }
Ktu, brenda klass, si publik sht definuar funksioni leximi, prmes s cilit lexohet vlera e variabls m. Meq funksioni prfshihet n klas, ai ka qasje
Klasat 147 direkte n kt variabl. Pastaj, ky funksion thirret n fillim t programit kryesor prmes komands:
Dita.leximi();
Nse ekzekutohet programi i dhn dhe prmes tastiers si vlera hyrse pr variablat m dhe a kompjuterit i jepen vlerat 77 dhe 44.56, rezultati do t duket si n Fig.4.3.

class5a
Inicializimi gjat deklarimit t objekteve

Nse variablat e prfshira n pjesn me t dhna t klass deklarohen vetm si publike, inicializimi i tyre mund t bhet edhe gjat deklarimit t objektit prkats. Shembull Versioni class5b i programit class5a, tek i cili variablat a dhe m jan prfshir n pjesn publike t klass Jeta, kurse inicializimi i tyre me vlera bhet gjat deklarimit t objektit prkats Dita.
// Programi class5b #include <iostream> using namespace std; class Jeta { public: int m; double a; void shtypja(); }; int main() { Jeta Dita={77,44.56};

Dita.shtypja(); return 0; } void Jeta::shtypja() { cout << "\nVlera e variabls private m=" << m << "\n\nVlera e variabls publike a=" << a << "\n\n"; }
Si shihet edhe n program, gjat deklarimit t objektit Dita:

Jeta Dita={77,44.56};
pas barazimit, brenda kllapave jan shnuar vlerat 77 dhe 44.56, t cilat u prgjigjen variablave m dhe a. Nse ekzekutohet programi i dhn, prmes funksionit shtypja, n ekran do t shtypen vlerat e variablave n fjal, ashtu si shihet edhe n pjesn e poshtme t Fig.4.3. Variablat q definohne si antar publik t klass mund t inicializohen me vlera edhe prej programit kryesor. Shembull Versioni class5c i programit class5b, tek i cili variablat a dhe m jan prfshir n pjesn publike t klass Jeta, kurse inicializimi i tyre bhet duke i lexuar vlerat prmes komandave prkatse n programin kryesor.
// Programi class5c #include <iostream> using namespace std; class Jeta { public: int m; double a; void shtypja(); }; int main() { Jeta Dita; cout << "\nLeximi i vlers s variabls m: ";
Klasat 149
cin >> Dita.m; cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a; Dita.shtypja(); return 0; } void Jeta::shtypja() { cout << "\nVlera e variabls private m=" << m << "\n\nVlera e variabls publike a=" << a << "\n\n"; }
Meq variablat m dhe a prfshihen n komponentet publike t klass, lejohet operimi me kto dy variabla n programin kryesor, duke e shfrytzuar emrin e objektit prkats dhe pikn si operator pr qasje, kshtu:
Dita.m Dita.a
Nse gjat ekzekutimit t programit t dhn m sipr, prmes tastiers kompjuterit i jepen dy vlerat hyrse 77 dhe 44.56, n ekran do ta kemi pamjen e dhn n Fig.4.3.
Shfrytzimi i vlerave t variablave private

Qasja direkte n program te variablat t cilat brenda klass jan deklaruar si private nuk lejohet. Por, pr shfrytzimin e tyre, brenda klass duhet t definohen funksione t veanta, t deklaruara si publike, prmes s cilave mundsohet marrja e vlerave t variablave n fjal. Gjat ksaj funksionet mund t jen pa parametra formal ose me parametra referent.
Funksionet pa parametra formal

Nse prmes funksioneve merret vlera vetm e nj variable q prfshihet n komponentet private t klasave, ather variabla duhet t shnohet te komanda return prkatse, pa shfrytzuar parametra formal. Shembull Programi class5b si version i programit class5a, tek i cili brenda klass Jeta sht definuar funksioni marrja n nj komponente publike, prmes s cilit n program, nga komponentja private merret vlera e variabls m.
// Programi class5b #include <iostream> using namespace std; class Jeta { private: int m; public: double a; void leximi(); void shtypja(); int merre(); }; int main() { int k; Jeta Dita; Dita.leximi(); cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a; k=Dita.merre(); cout << "\nVlera e variabls private m=" << k << "\n"; Dita.shtypja(); return 0; } void Jeta::leximi() { cout << "\nLeximi i vlers s variabls m: "; cin >> m; } void Jeta::shtypja() { cout << "\nVlera e variabls publike a=" << a << "\n\n"; }
Klasat 151
int Jeta::merre() { return m; }
Si shihet n fund t pjess s programit ku jan definuar funksionet, brenda funksionit merre sht vendosur vetm komanda:
return m;
me ka mundsohet marrja e vlers s variabls m, e cila sht deklaruar si private. Funksioni n fjal sht marr i tipit int, sepse vlera e variabls m q nxirret si rezultat sht e ktij tipi. Ky funksion, n program thirret prmes shprehjes:
k=Dita.merre();
dhe pas ksaj, te variabla k prcillet vlera e variabls m, e cila me ndrmjetsimin e funksionit leximi, prmes tastiers i sht dhn kompjuterit si vler hyrse. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket plotsisht njlloj me at q u dha n Fig.4.3.
Funksionet me parametra referent

Vlerat e variablave t cilat brenda klass jan deklaruar n komponentet private, mund t merren edhe duke shfrytzuar parametra referent. Kjo ka rndsi sidomos kur nevojitet q prmes nj funksioni prej komponenteve t klass t merren vlerat e disa variablave njkohsisht. Kur pas tipit t parametrit formal t nj funksioni shnohet simboli &, variabla prkatse bhet parametr referent. Pastaj, nse gjat thirrjes s funksionit, n vend t parametrit formal referent si parametr aktual shnohet nj variabl e zakonshme, adresa e parametrit aktual i shoqrohet parametrit formal. N kt mnyr, gjat ekzekutimit t programit, parametri formal e shfrytzon vlern q sht vendosur n adresn e parametrit aktual prkats. Shembull Programi class5c si version i programit class5b, tek i cili brenda klass Jeta sht definuar funksioni merre si publik, prmes s cilit n program, nga komponenta private, duke e shfrytzuar parametrin referent, merret vlera e variabls m.
// Programi class5c #include <iostream>

using namespace std; class Jeta { private: int m; public: double a; void leximi(); void shtypja(); void merre(int& k); }; int main() { int k; Jeta Dita; Dita.leximi(); cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a; Dita.merre(k); cout << "\nVlera e variabls private m=" << k << "\n"; Dita.shtypja(); return 0; } void Jeta::leximi() { cout << "\nLeximi i vlers s variabls m: "; cin >> m; } void Jeta::shtypja() { cout << "\nVlera e variabls publike a=" << a << "\n\n"; } void Jeta::merre(int& k) { k=m; return; }
Ktu, meq parametri formal i funksionit merre sht parametr referent, gjat thirrjes s tij prmes shprehjes:
Klasat 153
Dita.merre(k);
te parametri formal k, prmes adress prkatse prcillet vlera e variabls aktuale k, e cila mund t mos quhet me t njjtin emr. Te prototipi i funksionit, i cili sht shnuar brenda definicionit t klass, nuk sht e domosdoshme t shnohet edhe variabla k, por prototipi i funksionit mund t shkruhet edhe kshtu:
void Jeta::merre(int&)
Rezultati q do t fitohet, nse ekzekutohet programi i dhn pr vlera hyrse t njjta, do t duket si n Fig.4.3.
Llogaritjet me variablat e klass

Variablat q paraqiten n komponentet e klass mund t shfrytzohen gjat llogaritjeve t ndryshme, si n program ashtu edhe n funksionet q prfshihen brenda klass.
Llogaritjet n program
Shfrytzimi i variablave t klass n program varet nga ajo se a jan deklaruar komponentet prkatse si publike ose private. Nse variablat q jan antar t klass prfshihen n komponente publike, n program mund t shfrytzohen pa asnj penges, duke e shnuar para tyre emrin e objektit prkats dhe pikn. Nga ana tjetr, meq qasja direkte te variablat e klass, t cilat jan prfshir n komponente private, nuk sht e lejueshme, ato mund t merren vetm prmes funksioneve brenda klass, ashtu si u shpjegua m sipr. Shembull Programi class6a, si version i programit class5b, tek i cili sht shtuar edhe llogaritja e vlers s funksionit:
y = (m + 1)! + 3a
ku m dhe a jan variablat n komponentet e klass Jeta.

// Programi class6a #include <iostream> using namespace std; class Jeta {

private: int m; public: double a; void leximi(); void shtypja(); int merre(); }; int main() { int i,k; double F,y; Jeta Dita; Dita.leximi(); cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a; Dita.shtypja();
k=Dita.merre(); F=1; for (i=1;i<=(k+1);i++) F=F*i; y=F+3*Dita.a; cout << "\nVlera e funksionit y=" << y << "\n\n"; return 0; }
void Jeta::leximi() { cout << "\nLeximi i vlers s variabls m: "; cin >> m; } void Jeta::shtypja() { cout << "\nVlera e variabls private m=" << m << "\n\nVlera e variabls publike a=" << a << "\n"; } int Jeta::merre() { return m;
Klasat 155
}
N pjesn e programit pr llogaritjen e vlers s funksionit y jan shfrytzuar vlerat e variablave q paraqiten n komponentet me t dhna t klass Jeta. Vlera e variabls m, n program sht marr prmes funksionit merre dhe ruhet te variabla k. Kurse vlera e variabls a, meq brenda klass sht deklaruar si publike, sht marr direkt prej klass, duke e shnuar si Dita.a. Pr vlera hyrse t caktuara, rezultati n ekran do t duket si n Fig.4.4.
Fig.4.4 Pamja e ekranit pas ekzekutimit t programit class6a N program, pr ta ruajtur vlern e variabls m, e cila paraqitet n komponenten e klass, prsri mund t shfrytzohet variabla m. Tipi i ksaj variable, si edhe pr variabln k, q u shfrytzua m sipr, patjetr duhet t deklarohet. Pas ksaj, programi kryesor i programit class6 do t duket si n vijim.
int main() { int i,m; double F,y; Jeta Dita; Dita.leximi(); cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a; m=Dita.merre(); cout << "\nVlera e variabls private m=" << m << "\n"; Dita.shtypja(); F=1; for (i=1;i<=( m+1);i++) F=F*i; y=F+3*Dita.a; cout << "Vlera e funksionit y=" << y

<< "\n\n"; return 0; }
Vlerat e variablave nga komponentet e klass mund t merret prmes referencs. Shembull Programi class6b, si version i programit class6a, tek i cili sht shtuar edhe llogaritja e vlers s funksionit:
y = (m + 1)! + 3a
ku gjat shoqrimit t vlerave t variablave m dhe a n komponentet e klass Jeta shfrytzohet referenca.
// Programi class6b #include <iostream> using namespace std; class Jeta { private: int m; public: double a; void leximi(); void merre(int& k,double& x); }; int main() { int i,m; double a,F,y; Jeta Dita; Dita.leximi(); cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a; Dita.merre(m,a); cout << "\nVlera e variabls publike a=" << a << "\n" << "\nVlera e variabls private m=" << m << "\n\n"; F=1; for (i=1;i<=( m+1);i++) F=F*i;
Klasat 157
y=F+3*a; cout << "\nVlera e funksionit y=" << y << "\n\n"; return 0; } void Jeta::leximi() { cout << "\nLeximi i vlers s variabls m: "; cin >> m; } void Jeta::merre(int& k,double& x) { k=m; x=a; }
Ktu, prmes funksionit merre, prej komponenteve t klass merren njkohsisht vlerat e dy variablave m dhe a. Gjat ksaj, parametrat k dhe x q jan shnuar brenda kllapave t funksionit, meq jan deklaruar si variabla referente, njihen edhe si parametra referent. Nse ekzekutohet programi i dhn, rezultati prsri do t duket si n Fig.4.4. Lidhur me shfrytzimin e variablave referente m detajisht do t flitet n kapitullin e veant, i cili sht dhn n pjesn vijuese t librit.
Llogaritjet prmes funksioneve t klass

Prmes funksioneve q definohen brenda klasave definohen llogaritje t ndryshme, duke i shfrytzuar variablat q paraqiten n komponentet e tyre. Gjat ksaj, rezultatet e llogaritjeve mund t ruhen te variablat e komponenteve t klass, ose n variabla t zakonshme brenda programit ku deklarohen objektet e klasave n fjal.
Rezultatet te variablat e programit

Nse llogaritjet e ndryshme kryhen prmes funksioneve t cilat jan antar t klass, rezultatet prkatse mund t prcillen te variablat e programit, duke i thirrur funksionet n program. Shembull Programi class7, tek i cili brenda klass Llogaritja jan definuar funksionet vlerat dhe funkY. Prmes funksionit t par merren dhe shtypen vlerat e variablave m dhe a t deklaruara si private. Kurse, funksioni funkY shfrytzohet pr definimin e llogaritjes s vlers s funksionit:
y = (m + 1)! + 3a
ku m dhe a jan variablat n komponentet e klass.

// Programi class7 #include <iostream> using namespace std; class Llogaritja { private: int m; double a; public: void vlerat(int k,double x); double funkY(); }; int main() { double y; Llogaritja Koha; Koha.vlerat(2,9); y=Koha.funkY(); cout << "\nVlera e funksionit y=" << y << "\n\n"; return 0; } void Llogaritja::vlerat(int k,double x) { m=k; a=x; cout << "\nVlera e variabls m=" << m << "\n\nVlera e variabls a=" << a << "\n"; }
double Llogaritja::funkY() { int i; double F=1,y; for (i=1;i<=(m+1);i++) F=F*i;
Klasat 159
y=F+3*a; return y; }
Ktu, prmes funksionit funkY, i cili prfshihet n klas, prcaktohet llogaritja e vlers s funksionit y. Gjat ksaj, brenda tij shfrytzohen variablat m dhe a, t cilat prfshihen n komponentet e klass. N llogaritje shfrytzohen variablat ndihmse F dhe i, duke i deklaruar si variabla lokale. Pas deklarimit t objektit Koha t klass Llogaritja n fillim t programit, duke e shfrytzuar funksionin vlerat, prmes komands:
Koha.vlerat(2,9);
variablave m dhe a u shoqrohen vlerat 2 dhe 9, meq parametrat formal k dhe x t ktij funksioni jan zvendsuar me kta dy numra (si parametra aktual). Njkohsisht, prmes komandave q prfshihen brenda funksionit funkY, shtypen n ekran vlerat e ktyre dy variablave. N fund t programit, duke e thirrur funksionin:
y=Koha.funkY();
llogaritet vlera e funksionit y dhe me komandat vijuese ajo vler edhe shtypet, pr ta fituar rezultatin si n Fig.4.5.

class7
Gjat llogaritjeve prmes funksioneve q prfshihen n klas, prve variablave n komponentet e klass mund t shfrytzohen edhe variabla jasht klass. N kto raste, variablat e tilla duhet t paraqiten n listn e parametrave formal t funksioneve pr llogaritje. Shembull Programi classJ, prmes s cilit llogaritet vlera e funksionit
a pr a < 4 m + 2b 1 z = a + b + m pr a 4 2 ku m dhe a jan variablat n komponentet e klass Jeta. Pr llogaritje t vlers s variabls z, brenda klass shfrytzohet
160 Programimi i orientuar n objekte funksioni llogaritja, me parametrin formal b, prmes s cilit merret nga jasht vlera e variabls prkatse, meq nuk bn pjes n variablat e komponenteve t klass.
// Programi classJ #include <iostream> using namespace std; class Jeta { private: int m; double a; public: void vlerat(int k,double x); double llogaritja( double b); }; int main() { Jeta Dita; int k; double b,x, z; cout << "\nVlerat q lexohen" << "\n\nVariabla k: "; cin >> k; cout << "\nVariabla x: "; cin >> x; cout << "\nVariabla b: "; cin >> b; Dita.vlerat(k,x);
z=Dita.llogaritja( b);
cout << "\nVlera e llogaritur z=" << z << "\n\n"; return 0; } void Jeta::vlerat(int k,double x) { m=k; a=x; }
Klasat 161
double Jeta::llogaritja( double b) { double z; if (a<4) z=a/m+2*b-1; else z=a+b/2+m; return z; }
Te funksioni llogaritja, vlerat e variablave a dhe m merren direkt nga komponentet prkatse t klass. Kurse, variabla b sht deklaruar si parametr formal i funksionit, meq vlera e saj merret jasht klass. Nse ekzekutohet programi i dhn, pr vlera hyrse t caktuara, t cilat kompjuterit i jepen prmes tastiers, rezultati do t duket si n Fig.4.6.

classJ
Rezultatet te variablat e klass

Rezultati q fitohet prmes llogaritjeve brenda nj funksioni, q sht antar i klass, mund t ruhet direkt te variablat e klass, pavarsisht se a jan deklaruar ato si publike ose private. Por, marrja e tyre n programin kryesor do t dalloj varsisht se a jan deklaruar si publike ose private. Shembull Programi class8a, si version i programit class7, tek i cili pr ruajtjen e vlers s funksionit z, brenda klass, shfrytzohet nj variabl e veant e deklaruar si publike.
// Programi class8a #include <iostream> using namespace std; class Llogaritja

{ private: int m; double a; public: double z; void vlerat(int k,double x); void funkZ(); }; int main() { Llogaritja Koha; Koha.vlerat(2,9); Koha.funkZ(); cout << "\nVlera e funksionit z=" << Koha.z << "\n\n"; return 0; } void Llogaritja::vlerat(int k,double x) { m=k; a=x; cout << "\nVlera e variabls m=" << m << "\n\nVlera e variabls a=" << a << "\n"; } void Llogaritja::funkZ() { int i; double F=1; for (i=1;i<=(m+1);i++) F=F*i; z=F+3*a; return; }
Nse programi i dhn krahasohet me versionin class7, t dhn m sipr, do t vrehen ndryshimet vijuese. Brenda klass sht deklaruar si publike variabla z.
Klasat 163 Te funksioni funkZ m nuk deklarohet variabla lokale z, n t ciln te versioni class7 i programit ruhej rezultati i llogaritjes. Para funksionit funkZ sht shkruar fjala void n vend t tipit double, q ishte shnuar te versioni class7 i programit, sepse ktu rezultati i llogaritjes prcillet te variabla z, q prfshihet brenda klass. Prandaj, edhe n vazhdim t komands return t ktij funksioni m nuk figuron variabla z. Pr ta llogaritur vlern e funksionit z, n programin kryesor thirret funksioni funkZ prmes komands:
Koha.funkZ();
pasi paraprakisht te variablat m dhe a, duke e thirrur funksionin

vlerat si edhe m par:
Koha.vlerat(2,9);
prcillen vlerat 2 dhe 9. N fund, pr shtypjen e vlers s variabls z, e cila ruhet brenda klass si publike, te komanda pr shtypje shfrytzohet shprehja Koha.z.
Nse ekzekutohet programi class8a, rezultati do t duket plotsisht njlloj si ai q u dha n Fig.4.5. Nse variabla z te programi class8a, brenda klass Llogaritja deklarohet si private, pr marrjen e rezultatit q ruhet n t duhet t shfrytzohet nj funksion i veant, p.sh., merre, ashtu si shihet n vijim.
// Programi class8b #include <iostream> using namespace std; class Llogaritja { private: int m; double a; double z; public: void vlerat(int k,double x); void funkZ(); double merre(); };

int main() { Llogaritja Koha; Koha.vlerat(2,9); Koha.funkZ(); cout << "\nVlera e funksionit z=" << Koha.merre() << "\n\n"; return 0; } void Llogaritja::vlerat(int k,double x) { m=k; a=x; cout << "\nVlera e variabls m=" << m << "\n\nVlera e variabls a=" << a << "\n"; } void Llogaritja::funkZ() { int i; double F=1; for (i=1;i<=(m+1);i++) F=F*i; z=F+3*a; return; }
double Llogaritja::merre() { return z; }
Ktu, n fakt, funksioni merre sht thirrur brenda komands pr shtypje cout, duke e shfrytzuar formn Koha.merre(). Nse ekzekutohet ky version i programit, rezultati prsri do t duket plotsisht njlloj si ai q shihet n Fig.4.5. Gjat deklarimit t pjess s klass me komponentet private nuk sht e thn q variablat a dhe z t deklarohen ve. Por, ato mund t deklarohen edhe kshtu:
private: int m; double a, z;
Klasat 165
Shfrytzimi i funksioneve brenda klass

Funksionet e prfshira n komponentet e klass mund t shfrytzohen pr llogaritje brenda vet klass, pavarsisht se a jan prfshir n komponentet private ose n komponentet publike t saj.
Funksionet n komponentet publike

Shfrytzimi i funksioneve brenda klass ose edhe jasht saj, prkatsisht n programin kryesor, nse jan prfshir n komponentet e deklaruara si publike, nuk ka asnj kufizim. Shembull Programi classF1, prmes s cilit llogaritet vlera e funksionit:
n+1
g = 3x + 4
i=1
(2i + a)
nse variablat x, n dhe a deklarohen n komponenten private t klass Alfa. Kurse, pr llogaritje t shums shfrytzohet funksioni shuma i prfshir n komponentet publike t tij. Gjithashtu, brenda strukturs s klass prfshihen edhe funksionet Vlerat dhe FunkG - njri pr leximin e vlerave t variablave q jan prfshir n komponentet private t klass, kurse tjetri pr llogaritjen e vlers s funksionit g.
// Programi classF1 #include <iostream> using namespace std; class Alfa { private: int n; double a,x; public: void Vlerat(); double Shuma(); double FunkG(); }; int main() { Alfa Dita; Dita.Vlerat();

cout << "\nVlera e llogaritur g=" << Dita.FunkG() << "\n\n"; return 0; } void Alfa::Vlerat() { cout << "\nVlerat e variablave" << "\n\nVariabla n: "; cin >> n; cout << "\nVariabla a: "; cin >> a; cout << "\nVariabla x: "; cin >> x; }
double Alfa::Shuma() { int i; double s=0; for (i=1;i<=(n+1);i++) s=s+(2*i+a); return s; }

double Alfa::FunkG() { double g; g=3*x+4*Shuma(); return g; }
Ktu, brenda klass sht definuar funksioni Shuma, pr llogaritjen e vlers s shums q paraqitet n shprehjen e funksionit g. Pastaj, ai shfrytzohet te funksioni FunkG pr llogaritjen e vlers s funksionit g, i cili prfshihet n komponenten e klass. Rezultati n ekran, pr vlera hyrse t caktuara, do t duket si ai q sht dhn n Fig.4.7.
Fig.4.7
Klasat 167 Pamja e ekranit pas ekzekutimit t programit classF1 Brenda klass Alfa te programi i msiprm mund t prfshihet edhe rezultati, prkatsisht variabla g. N kt rast, programi me ndryshimet e nevojshme do t duket ashtu si sht dhn n vijim.
// Programi classF2 #include <iostream> using namespace std; class Alfa { private: int n; double a,x; public: double g; void Vlerat(); double Shuma(); void FunkG(); }; int main() { Alfa Dita; Dita.Vlerat(); Dita.FunkG(); cout << "\nVlera e llogaritur g=" << Dita.g << "\n\n"; return 0; } void Alfa::Vlerat() { cout << "\nVlerat e variablave" << "\n\nVariabla n: "; cin >> n; cout << "\nVariabla a: "; cin >> a; cout << "\nVariabla x: "; cin >> x; } double Alfa::Shuma() { int i;

double s=0; for (i=1;i<=(n+1);i++) s=s+(2*i+a); return s; }
void Alfa::FunkG() { g=3*x+4*Shuma(); return; }
Ktu, meq rezultati g ruhet brenda strukturs s klass, para funksionit prkats shnohet fjala void. Gjithashtu, rezultati n programin kryesor shtypet duke e shfrytzuar shprehjen Dita.g, prmes s cils vlera g merret nga komponentja publike e klass s objektit Dita. Nse ekzekutohet ky version i programit, pr vlera hyrse t njjta, rezultati do t duket si ai q u dha m sipr, n Fig.4.7.
Funksionet n komponentet private

Kur funksionet vendosen n komponentet private, shfrytzimi i tyre brenda klass nuk ka kufizim. Por, thirrja direkte e tij jasht klass, prkatsisht n programin kryesor, nuk sht e mundshme. Shembull Programi classF3 prmes s cilit llogaritet vlera e funksionit:
z = (2m + 1)!+3a
nse variablat m dhe a deklarohen n komponenten private t klass Gama. Kurse, pr llogaritje t faktorielit shfrytzohet funksioni Fakt, i cili prfshihet n nj komponente private t klass. Gjithashtu, brenda strukturs s klass prfshihen edhe funksionet Vlerat dhe FunkZ - njri pr marrjen e vlerave t variablave q jan prfshir n komponentet private t klass, kurse tjetri pr llogaritjen e vlers s funksionit z.
// Programi classF3 #include <iostream> using namespace std; class Gama { private:
Klasat 169
int m; double a; double Fakt(int n); public: void vlerat(int k,double x); double funkZ(); }; int main() { double z; Gama Koha; Koha.vlerat(2,9); z=Koha.funkZ(); cout << "\nVlera e funksionit z=" << z << "\n\n"; return 0; } void Gama::vlerat(int k,double x) { m=k; a=x; cout << "\nVlera e variabls m=" << m << "\n\nVlera e variabls a=" << a << "\n"; }
double Gama::Fakt(int n) { int i; double F=1; for (i=1;i<=n;i++) F=F*i; return F; }

double Gama::funkZ() { double z; z=Fakt(m+1)+3*a; return z; }
Prmes funksionit Fakt, ktu sht definuar llogaritja e funksionit F=n!, duke e marr variabln n si parametr formal. Gjat llogaritjes s vlers s
170 Programimi i orientuar n objekte funksionit z, meq funksioni Fakt sht n njrn nga komponentet e klass, ai sht thirrur direkt, duke e zvendsuar parametrin formal n me at aktual m+1. Nse ekzekutohet programi i dhn, pr vlerat aktuale 2 dhe 9 t variablave m dhe a, t cilat kompjuterit i jepen direkt gjat thirrjes s funksionit vlerat, rezultati do t duket si n Fig.4.8.

classF3
Deklarimi i disa objekteve

Duke e shfrytzuar klasn e definuar, brenda nj programi, njkohsisht mund t deklarohen m shum objekte. Objektet e deklaruara shfrytzohen si objekte t veanta, t pavarura nga njri a tjetri. Shembull Programi classM, prmes s cilit llogaritet vlera e funksionit:
y = 3a + (2m 1)!
nse variablat m dhe a deklarohen n komponenten private t klass Alfa.

// Programi classM #include <iostream> using namespace std; class Alfa { private: int m; double a; public: double y; void Vlerat(int k,double x); void Funk(); }; int main() { cout << "\nObjekti Dita" << "\n------------"
Klasat 171
<< "\n"; Alfa Dita; Dita.Vlerat(2,9); Dita.Funk(); cout << "\nVlera e funksionit y=" << Dita.y; cout << "\n\n\nObjekti Nata" << "\n------------" << "\n"; Alfa Nata; Nata.Vlerat(3,7); Nata.Funk(); cout << "\nVlera e funksionit y=" << Nata.y << "\n\n"; return 0; } void Alfa::Vlerat(int k,double x) { m=k; a=x; cout << "\nVlera e variabls m=" << m << "\n\nVlera e variabls a=" << a << "\n"; } void Alfa::Funk() { int i; double F=1; for (i=1;i<=(2*m-1);i++) F=F*i; y=3*a+F; }
Prmes funksionit Vlerat, i cili prfshihet n komponenten publike t klass, inicializohen variablat m dhe a t prfshira n komponentet private t klass Alfa. Kurse, pr llogaritjen e vlers s funksionit y, i cili prfshihet n komponenten publike t klass, shfrytzohet funksioni Funk. N program jan deklaruar objektet Dita dhe Nata t klass Alfa. Gjat ksaj, pr vlerat hyrse, t cilat u jan shoqruar variablave m dhe a t objekteve prkatse prmes funksionit Vlerat, jan llogaritur dy vlera t funksionit y, duke e shfrytzuar funksionin Funk, ashtu si shihet n Fig.4.9.

classM
Objektet Dita dhe Nata t klass Alfa mund t deklarohen edhe me nj komand n fillim t programit, kshtu:
Alfa Dita,Nata;
Ngjashm mund t veprohet edhe nse njkohsisht brenda programit deklarohen m shum objekte.
Konstruktort
Me qllim t inicializimit t variablave t cilat prfshihen n komponentet e klass, brenda saj definohen funksione t veanta, t cilat njihen si konstruktor.
Klasat 173 Kto funksione ekzekutohen automatikisht, kur deklarohen objektet prkatse t klasave n fjal. Konstruktort dallohen nga funksionet e zakonshme brenda klass, sepse kan emra t njjt me klasat dhe para emrave t tyre si dhe te komandat e fundit return nuk shnohet asgj. Konstruktort mund t ken ose mund t mos ken parametra formal.
Konstruktort pa parametra formal

Nse prcaktimi i vlerave t variablave n komponentet private bhet brenda konstruktorve, ato mund t mos ken parametra formal.
Shembull
Programi class9, prmes s cilit llogaritet siprfaqja s dhe perimetri p i rrethit me rreze r. Pr inicializimin e konstantes pi, brenda klass rrethi, e cila definohet n program shfrytzohet konstruktori prkats.
// Programi class9 #include <iostream> using namespace std; class rrethi { private: double pi,r,s,p; public: rrethi(); void rrezja(double x); void llogaritja(); void shtypja(); }; int main() { rrethi Alfa; double x; cout << "\nRrezja e rrethit x: "; cin >> x; Alfa.rrezja(x); Alfa.llogaritja(); Alfa.shtypja(); return 0; }
rrethi::rrethi()

{ pi=3.1415926; }
void rrethi::rrezja(double x) { r=x; } void rrethi::llogaritja() { s=pi*r*r; p=2*pi*r; return; } void rrethi::shtypja() { cout << "\nVlerat e llogaritura" << "\n\nSiprfaqja s=" << s << "\n\nPerimetri p=" << p << "\n\n"; }
N program, meq klasa sht quajtur me emrin rrethi, edhe konstruktori pr inicializimin e konstantes pi, e cila brenda klass sht deklaruar si private, quhet njlloj. N kt mnyr, n momentin kur n program deklarohet objekti Alfa i klass rrethi:
rrethi Alfa;
automatikisht ekzekutohet funksioni rrethi dhe konstantes pi i shoqrohet vlera prkatse. Pastaj, pasi prmes tastiers kompjuterit t'i jepet vlera e variabls x, kur thirret funksioni rrezja:
Alfa.rrezja(x);
variabls r, e cila e paraqet rrezen e rrethit, i shoqrohet kjo vler. N fund, n program thirren funksionet llogaritja dhe shtypja, prmes t cilave s pari llogariten siprfaqja s dhe perimetri p i rrethit, dhe pastaj vlerat e llogaritura edhe shtypen. Rezultati q fitohet n ekran, pr vlern hyrse 5 t variabls x, do t duket si n Fig.4.10.
Klasat 175
Fig.4.10 Pamja e ekranit pas ekzekutimit t programit class9 Nuk sht e thn q vlerat e variablave private brenda klass t jen vetm konstante. Ato mund t lexohen si vlera t fardoshme edhe nga jasht.
Shembull
Programi class10a, prmes s cilit llogaritet siprfaqja s dhe perimetri p i drejtkndshit me brinjt a dhe b. Shoqrimi i vlerave pr variablat e brinjve a dhe b, brenda klass kater q definohet n program, bhet prmes konstruktorit prkats.
// Programi class10a #include <iostream> using namespace std; class kater { private: double a,b,s,p; public: kater(); void llogaritja(); void shtypja(); }; int main() { kater Omega; Omega.llogaritja(); Omega.shtypja(); return 0; }
kater::kater() { cout << "\nVlerat e lexuara" << "\n\nBrinja a: "; cin >> a; cout << "\nBrinja b: ";

cin >> b; }
void kater::llogaritja() { s=a*b; p=2*(a+b); return; } void kater::shtypja() { cout << "\nVlerat e llogaritura" << "\n\nSiprfaqja s=" << s << "\n\nPerimetri p=" << p << "\n\n"; }
Ktu, brenda konstruktorit kater jan prfshir komandat pr leximin e vlerave t variablave a dhe b, t cilat paraqiten n komponentet private t klass. Pas deklarimit t objektit Omega, jan thirr dy funksionet e prfshira brenda klass prkatse:
Omega.llogaritja(); Omega.shtypja();
ashtu q s pari t llogariten siprfaqja dhe perimetri i drejtkndshit dhe pastaj t shtypen ato vlera. Nse ekzekutohet programi i dhn dhe pr brinjt e drejtkndshit, prmes tastiers kompjuterit i jepen vlerat 5 dhe 4, rezultati n ekran do t duket si n Fig.4.11.

class10a
Klasat 177
Konstruktort me parametra formal

Prmes konstruktorve, si edhe prmes funksioneve t zakonshme, variablave brenda klass mund t'u shoqrohen edhe vlera t fardoshme. Shembull Versioni class10b i programit class10a, tek i cili konstruktori kater ka edhe dy parametra formal x dhe y.
// Programi class10b #include <iostream> using namespace std; class kater { private: double a,b,s,p; public: kater(double x,double y); void llogaritja(); void shtypja(); }; int main() { double x,y; cout << "\nVlerat e lexuara" << "\n\nBrinja a: "; cin >> x; cout << "\nBrinja b: "; cin >> y;
kater Omega(x,y); Omega.llogaritja(); Omega.shtypja(); return 0; } kater::kater(double x,double y) { a=x; b=y; }

void kater::llogaritja() { s=a*b; p=2*(a+b);

return; } void kater::shtypja() { cout << "\nVlerat e llogaritura" << "\n\nSiprfaqja s=" << s << "\n\nPerimetri p=" << p << "\n\n"; }
Ktu, parametrat formal te konstruktori kater shfrytzohen pr prcjelljen brenda tij t vlerave x dhe y, t cilat lexohen n programin kryesor. Pastaj, kto vlera u shoqrohen variablave a dhe b t klass, prmes shprehjeve:
a=x; b=y;
t cilat prfshihen te konstruktori. Meq n momentin e deklarimit t objektit t klass kater automatikisht thirret edhe konstruktori, deklarimi i objektit duhet t shoqrohet edhe me vlerat aktuale t ktyre dy parametrave. Pr kt arsye, deklarimi i objektit Omega i klass kater sht br n formn:
kater Omega(x,y);
ku variablat x dhe y paraqesin parametra aktual, vlerat e t cilve jan lexuar paraprakisht. Rezultati q fitohet n ekran, pr vlerat hyrse 5 dhe 4 t brinjve a dhe b, do t duket si n Fig.4.11. N literatur takohet edhe nj form tjetr e definimit t konstruktorve. Kjo form, p.sh., pr konstruktorin i cili u shfrytzua te programi i msiprm mund t duket:
kater::kater(double x,double y):a(x),b(y) { }
Edhe pas definimit t konstruktorit n kt mnyr, deklarimi i objektit Omega t klass kater n program nuk do t ndryshoj.
Klasat 179
Gjat prcaktimit t vlerave duke e shfrytzuar kt form t shkruarjes s konstruktorve, brenda kllapave t variablave mund t shkruhen vlera numerike konkrete. Shembull Programi class11, prmes s cilit llogaritet vlera e funksionit:
y = ax + (m + 1)!
nse variablat m dhe x prfshihen n komponentet private t klass Alfa, kurse variabla a merret si variabl e jashtme.
// Programi class11 #include <iostream> using namespace std; class Alfa { private: int m; double x; public: Alfa(); double Funk(double a); }; int main() { double y; Alfa Dita; y=Dita.Funk(6.5); cout << "\nVlera e llogaritur y=" << y << "\n\n"; return 0; }
Alfa::Alfa():m(3),x(5) { cout << "\nVlera e variabls m: " << m << "\n\nVlera e variabls x: " << x << "\n";

} double Alfa::Funk(double a) { double F=1,y; int i; for (i=1;i<=(m+1);i++) F=F*i; y=a*x+F; return y; }
N kt rast, prmes konstruktorit jan inicializuar direkt variablat m dhe x me vlerat 3 dhe 5 - prkatsisht, duke i shnuar:
Alfa::Alfa(): m(3),x(5)
kurse gjat thirrjes s funksionit Funk:

y=Dita.Funk(6.5);
parametri formal a sht zvendsuar me vlern aktuale 6.5. Rezultati n ekran pas ekzekutimit t programit t dhn do t duket si n Fig.4.12.

class11
Llogaritjet brenda konstruktorve

Prve inicializimit t variablave me vlera, brenda konstruktorve mund t kryhen edhe llogaritje t ndryshme. Por, rezultatet e llogaritjeve duhet t prcillen te variablat e prfshira n komponentet e klasave. Shembull Programi class12a, prmes s cilit llogariten vlerat e funksionit:
n+1 i=1
y = 3x + k
(2i + a)
Variablat x, k, a dhe n, si dhe rezultati i llogaritjes y, ruhen n klasn Omega. Kurse, pr inicializimin e variablave dhe pr llogaritje shfrytzohet konstruktori prkats.
Klasat 181
// Programi class12a #include <iostream> using namespace std; class Omega { private: int n,k; double x,a; public: double y; Omega(); }; int main() { Omega Delta; cout << "\nVlera e llogaritur y=" << Delta.y << "\n\n"; return 0; } Omega::Omega() { cout << "\nVlerat inicializuese" << "\n\nVariabla n: "; cin >> n; cout << "\nVariabla x: "; cin >> x; cout << "\nVariabla a: "; cin >> a; cout << "\nVariabla k: "; cin >> k;
int i; double s=0; for (i=1;i<=(n+1);i++) s=s+(2*i+a); y=3*x+k*s;

}
Ktu, brenda konstruktorit Omega fillimisht sht parapar inicializimi me vlera i variablave q prfshihen n komponentet e klass prmes leximit t tyre. Pastaj, sht vazhduar me llogaritjen e shums s dhe t vlers s funksionit y. Rezultati q fitohet n ekran, pr vlera hyrse t zgjedhura lirisht, do t duket si n Fig.4.13.

class12a
Rezultati y, qllimisht sht ruajtur n komponenten publike t klass, ashtu q gjat shtypjes t merret direkt, duke e shfrytzuar shprehjen Delta.y. Nse gjat ekzekutimit t programit vlerat e variablave t caktuara brenda klass nuk ndryshojn, ato mund t inicializohen direkt gjat deklarimit t objektit prkats. Shembull Versioni class12b i programit class12a, tek i cili pr inicializimin e variablave k dhe a jan shfrytzuar parametrat formal p dhe q t konstruktorit Omega.
// Programi class12b #include <iostream> using namespace std; class Omega { private: int n,k; double x,a; public: double y; Omega(int p,double q); }; int main() { Omega Delta(3,1.7); cout << "\n\nVlera e llogaritur y=" << Delta.y << "\n\n"; return 0; }
Klasat 183
Omega::Omega(int p,double q) { n=p; a=q; cout << "\nVlerat inicializuese" << "\n\nVariabla x: "; cin >> x; cout << "\nVariabla k: "; cin >> k; cout << "\nVariabla a: " << a << "\n\nVariabla n: " << n;
int i; double s=0; for (i=1;i<=(n+1);i++) s=s+(2*i+a); y=3*x+k*s; }
Ktu, gjat deklarimit t objektit Omega t klass Delta:

Omega Delta(3,1.7);
jan inicializuar variablat n dhe a, duke i shnuar parametrat aktual 3 dhe 1.7, n vend t parametrave formal p dhe q. Nse ekzekutohet ky version i programit, pr vlera hyrse t njjta, rezultati n ekran nuk do t ndryshoj nga ai q u dha n Fig.4.13.
Disa konstruktor njkohsisht

Brenda nj klase mund t prfshihen edhe disa konstruktor njkohsisht. Kjo lidhet me krijimin e disa objekteve t klass n fjal, ashtu q objektet e ndryshme t mund ta shfrytzojn njrin nga konstruktort e definuar. Thirrja automatike e konstruktorit t caktuar lidhet me deklarimin e objektit prkats dhe varet nga numri i parametrave aktual ose nga tipi i tyre. N kt rast, meq njkohsisht definohen disa konstruktor, flitet pr konstruktor t mbingarkuar (ang. overloading).
Thirrja n baz t numrit t parametrave

Nse konstruktort e prfshir n definicionin e klass dallohen mes vete pr nga numri i parametrave, prfshir edhe konstruktorin pa parametra, kompjuteri do ta thrras automatikisht konstruktorin i cili ka aq parametra
184 Programimi i orientuar n objekte formal sa jan shnuar brenda kllapave gjat deklarimit t objektit prkats n program. Shembull Programi class13, prmes s cilit llogariten vlerat e funksioneve:
y = 5x + 3 ! x z = + (m + 1)! 2
duke shfrytzuar dy konstruktor pr prcaktimin e vlerave q lidhen me faktorielt t cilt duhet t llogariten.
// Programi class13 #include <iostream> using namespace std; class faktoriel { private: int m; double x; public: double g; faktoriel(); faktoriel(int k); }; int main() { faktoriel Dita; cout << "\nVlera e llogaritur y=" << Dita.g; faktoriel Nata(3); cout << "\nVlera e llogaritur z=" << Nata.g << "\n\n"; return 0; } faktoriel::faktoriel() { m=3; cout << "\nKonstruktori i par" << "\n-------------------" << "\n\nVariabla x: ";
Klasat 185
cin >> x; double F=1; int i; for (i=1;i<=m;i++) F=F*i; g=5*x+F; }
faktoriel::faktoriel(int k) { m=k; cout << "\n\n\nKonstruktori i dyt" << "\n-------------------" << "\n\nVariabla x: "; cin >> x; double F=1; int i; for (i=1;i<=(m+1);i++) F=F*i; g=x/2+F; }
Brenda klass faktoriel ktu shfrytzohen dy konstruktor me emrin faktoriel, t cilt jan vendosur n komponentet publike dhe shkruhen:
faktoriel(); faktoriel(int k);
Prmes parametrit k, n konstruktorin e dyt prcaktohet vlera e variabls m, sepse brenda tij paraqitet shprehja m=k. Kurse, n konstruktorin e par sht marr m=3, pa pasur mundsi q vlera e variabls m t merret edhe ndryshe. Prmes konstruktorve t dhn, prve q prcaktohet vlera e variabls m, llogaritet edhe njra prej vlerave t funksioneve y dhe z, e cila ruhet brenda klass te variabla g. Se cila vler do t llogaritet, varet nga prezenca ose mosprezenca e parametrit k gjat deklarimit t objektit prkats t klass. N program, duke e shfrytzuar klasn faktoriel, jan deklaruar objektet Dita dhe Nata. Meq gjat deklarimit t objektit t par:
faktoriel Dita;
nuk shoqrohet asnj vler, automatikisht do t aktivizohet konstruktori i par, prmes s cilit llogaritet vlera e funksionit y. Kurse, gjat deklarimit t objektit t dyt:
faktoriel Nata(3);
186 Programimi i orientuar n objekte meq brenda kllapave sht shnuar vlera 3, e cila i prket parametrit formal k, automatikisht aktivizohet konstruktori i dyt dhe do t llogaritet vlera e funksionit z. Nse ekzekutohet programi i dhn, rezultati do t duket si n Fig.4.14.

class13
Thirrja n baz t tipit t parametrave

Nse konstruktort e prfshir n definicionin e klass dallohen mes vete pr nga tipi i parametrave, kompjuteri do ta thrras automatikisht konstruktorin me tip t njjt t parametrave formal me parametrat aktual q jan shnuar brenda kllapave gjat deklarimit t objektit prkats n program. Shembull Programi class14, prmes s cilit llogariten vlerat e funksioneve:
y = 3 z = 2
i=1 n+1 i=1
+ 1 2 i
[3i + 4]
duke shfrytzuar dy konstruktor Shuma pr prcaktimin e llogaritjes s vlerave t shumave t veanta.

// Programi class14 #include <iostream> using namespace std; class Shuma { private: int n; public:
Klasat 187
double s; Shuma(double a); Shuma(int a); }; int main() { char v[]="-------------"; double y; cout << "\nObjekti Alfa\n" << v; Shuma Alfa(0.5); y=3*Alfa.s; cout << "\nVlera e llogaritur y=" << y; double z; cout << "\n\n\nObjekti Beta\n" << v;
Shuma Beta(3); z=2*Beta.s; cout << "\nVlera e llogaritur z=" << z << "\n\n"; return 0; } Shuma::Shuma(double a) { cout << "\n\nVariabla n: "; cin >> n; int i; s=0; for (i=1;i<=n;i++) s=s+(a*i+1); } Shuma::Shuma(int a) { cout << "\n\nVariabla n: "; cin >> n; int i; s=0; for (i=1;i<=(n+1);i++) s=s+(a*i+4); }
188 Programimi i orientuar n objekte Ktu, konstruktort Shuma shfrytzohen pr inicializimin e vlerave t variablave n prmes leximit. Gjithashtu, llogariten vlerat e shumave, duke e shnuar, n vend t konstantes para variabls i, parametrin a, kshtu:
a i + 1 a i + 4
Meq, pr llogaritjen e vlers s funksionit y, gjat deklarimit t objektit prkats:

Shuma Alfa(0.5);
parametri formal a sht zvendsuar me numrin dhjetor 0.5, i cili i prgjigjet thyess 1/2 para variabls i, kompjuteri do ta aktivizoj konstruktorin e par Shuma, tek i cili ky parametr sht deklaruar i tipit double. Kurse, n rastin e llogaritjes s vlers s funksionit z, kompjuteri do ta shfrytzoj konstruktorin e dyt Shuma, sepse gjat deklarimit t objektit prkats:
Shuma Beta(3);
parametri formal a i tipit int, te ky konstruktor zvendsohet me numrin e plot 3. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.4.15.

class14
Destruktort
Me qllim t lirimit t hapsirs memoruese, t ciln e shfrytzon nj objekt, pasi objekti m nuk nevojitet, brenda klass definohet nj funksion i veant, i cili njihet si destruktor. Si konstruktori, edhe emri i destruktorit sht i
Klasat 189 njjt me emrin e klass, por para tij vendoset simboli ~. Brenda kllapave t trupit t destruktorit vendoset komanda delete, n vazhdim t s cils shnohen variablat e klass t cilat duhet t fshihen, t ndara mes vete me presje. Kshtu, p.sh., destruktori q vendoset brenda klass Alfa mund ta ket formn:
~Alfa() { cout << "Aktivizimi i destruktorit"; delete m,a; }
Destruktori mund t shfrytzohet vetm pr fshirje t objekteve t deklaruara si pointer. Kur prfundon ekzekutimi i programit, nse nuk shfrytzohen destruktor, kompjuteri automatikisht i fshin objektet e shfrytzuara brenda tij. Prandaj, edhe shfrytzimi i destruktorve te programet e zakonshme nuk ka ndonj rndsi t veant.
Disa klasa njkohsisht

Nj program mund t prmbaj edhe disa klasa njkohsisht. Pr definimin dhe shfrytzimin e tyre vlejn rregullat sikur edhe pr nj klas t vetme. Shembull Programi classK2, prmes s cilit llogariten siprfaqja sd dhe perimetri pd i drejtkndshit me brinjt a dhe b, si dhe siprfaqja sr dhe perimetri pr i rrethit me rreze r. Gjat llogaritjeve shfrytzohen dy klasa t veanta drejtk dhe rrethi, n komponentet private t s cilave ruhen brinjt e drejtkndshit dhe konstantja pi me rrezen r t rrethit. Kurse, funksionet pr marrjen e vlerave t nevojshme (vleratD dhe vleratR), si dhe funksionet pr llogaritje (llogaritD dhe llogaritR) jan definuar si antar publik t klasave.
// Programi classK2 #include <iostream> using namespace std;
class drejtk { private: double a,b; public: void vleratD(double x,double y); void llogaritD();

};
class rrethi { private: double pi,r; public: void vleratR(double x,double y); void llogaritR(); };
int main() { drejtk D; rrethi R; D.vleratD(7,4); D.llogaritD(); R.vleratR(3.1415926,5); R.llogaritR(); return 0; } void drejtk::vleratD(double x,double y) { a=x; b=y; cout << "\nBrinjt e drejtkndshit" << "\n\nBrinja a=" << a << "\nBrinja b=" << b << "\n"; } void drejtk::llogaritD() { double sd,pd; sd=a*b; pd=2*(a+b); cout << "\nSiprfaqja e drejtkndshit sd=" << sd << "\nPerimetri i drejtkndshit pd=" << pd << "\n"; } void rrethi::vleratR(double x,double y) {
Klasat 191
pi=x; r=y; cout << "\nRrezja e rrethit r=" << r << "\n"; } void rrethi::llogaritR() { double sr,pr; sr=pi*r*r; pr=2*pi*r; cout << "\nSiprfaqja e rrethit sr=" << sr << "\nPerimetri i rrethit pr=" << pr << "\n\n"; }
Te funksionet e veanta t prfshira n klasa jan shfrytzuar edhe komanda pr shtypje t vlerave hyrse si dhe vlerat e rezultateve q fitohen gjat llogaritjeve. N kt mnyr, programi kryesor sht thjeshtuar krejtsisht. N t fillimisht deklarohen objektet D dhe R:
drejtk D; rrethi R;
t klasave drejtk dhe rrethi. Pastaj jan thirrur funksionet:

D.vleratD(7,4); D.llogaritD(); R.vleratR(3.1415926,5); R.llogaritR();
pr marrje t vlerave, llogaritje dhe shtypje t rezultateve. Rezultati n ekran do t duket si n Fig.4.16.
Fig.4.16
192 Programimi i orientuar n objekte Pamja e ekranit pas ekzekutimit t programit classK2 Ngjashm si n shembullin e msiprm, n nj program mund t definohen dhe t shfrytzohen edhe m shum klasa njkohsisht.
Trashgimia
Prmes mekanizmit t trashgimis (ang. inheritance), antart e klass ekzistuese mund t shfrytzohen gjat definimit t klasave t reja. Kjo ka nj rndsi t veant, sepse mundsohet plotsimi me komponente i nj klase ekzistuese, gj q mund t shfrytzohet gjat prmirsimit t programeve q jan n shfrytzim, ose t prfshira n biblioteka t ndryshme programesh t gatshme. Klasa ekzistuese njihet si klas baz (ang. base class), kurse klasa e re i trashgon karakteristikat e klass baz dhe quhet klas e nxjerr (ang. derived class). Klasa e re krijohet duke e plotsuar klasn ekzistuese me antar t tjer, qofshin ato antar t dhnash ose funksione. Gjat ksaj, klasa baz nuk pson asnj ndryshim. Njkohsisht, klasa e nxjerr mund t shfrytzohet si klas baz pr nxjerrjen e klasave t tjera. Nj mundsi e till e krijimit t klasave t reja, si prej klasave baz ashtu edhe prej klasave t nxjerra, prmes mekanizmit t trashgimis, paraqet nj organizim hierarkik t klasave, gj q programimin e orientuar n objekte e bn edhe m t fuqishm. Organizimi i till hierarkik, p.sh., mund t duket si ai q sht dhn n Fig.4.17, ku prej klass baz Person jan nxjerr klasat Profesori dhe Studenti. Pastaj, prej klass Studenti jan nxjerr klasat Provimet dhe Notat.
Fig.4.17 Dukja e nj organizimi hierarkik t klasave
Ktu, nnkuptohet se hierarkia mund t vazhdohet m tutje edhe pas klass s nxjerr Profesori. Gjat ksaj, shigjetat jan t drejtuara prej klasave t nxjerra kah klasa baz dhe prmes tyre tregohet se prej cils klas jan nxjerr klasat e veanta. Nse analizohet hierarkia e dhn, do t shihet se klasat e nxjerra, n fakt, e plotsojn klasn baz me t dhna dhe funksione t tjera. Kshtu, p.sh., nse
Klasat 193 te klasa Person prfshihen t dhnat bazike, si jan emri, vendi, datlindja etj., prmes klass s nxjerr Studenti t dhnat baz plotsohen, p.sh., me t dhnat pr fakultetin, drejtimin e zgjedhur etj. M tutje, t gjitha ktyre t dhnave mund t'u shtohen edhe ato pr provimet e studentve (klasa e nxjerr Provimet) dhe pr pagesat e tyre (klasa e nxjerr Pagesat). Meq shembulli i programit ku do t paraqitej hierarkia e dhn m sipr, ose edhe pjes t saj, krkon m shum hapsir, n vijim do t jepen disa shembuj m elementar. Shembull Programi classT1a, n t cilin definohet klasa Alfa si klas baz dhe klasa Beta - si klas e nxjerr prej saj.
// Programi classT1a #include <iostream> using namespace std;
class Alfa { private: int a; public: double b; void Jeta() { a=5; b=8; cout << << << << << << } };
"\nVlerat te klasa Alfa" "\n\n a=" a "\n b=" b "\n\n";
class Beta: public Alfa { private: double c; public: int d; void Dita() {

b=2; c=4; d=7; cout << << << << << << << << } }; int main() { Alfa X; Beta Y; X.Jeta(); Y.Dita(); X.Jeta(); return 0; }
"Vlerat te klasa Beta" "\n\n b=" b "\n c=" c "\n d=" d "\n";
N program, fillimisht sht definuar klasa Alfa. Te funksioni Jeta i cili sht deklaruar si publik, variablave a dhe b t klass u jan shoqruar vlerat prkatse 5 dhe 8. Njkohsisht, prmes komands cout sht urdhruar shtypja e ktyre vlerave. Pastaj sht definuar klasa Beta, n t ciln, prve komponenteve t saj, jan deklaruar si publike edhe komponentet publike t klass Alfa, gj q arrihet prmes deklarimit public Alfa, kshtu:
class Beta: public Alfa
Klasa Beta llogaritet si klas e nxjerr nga klasa Alfa, meq brenda saj shfrytzohen edhe komponentet publike t klass Alfa. Brenda klass Alfa mund t shfrytzohen vetm variablat a dhe b, si dhe funksioni Jeta. Por, nuk mund t shfrytzohen variablat c e d, si dhe funksioni Dita, t cilt paraqiten n komponentet e klass s nxjerr Beta. Meq komponentet publike t klass Alfa jan deklaruar njkohsisht si publike edhe te klasa Beta, te kjo klas mund t shfrytzohet edhe variabla b, si dhe funksioni Jeta. Brenda klass Beta nuk mund t shfrytzohet variabla a, e cila sht antar i klass Alfa, por e deklaruara si private.
Klasat 195 N program, fillimisht jan deklaruar objektet X dhe Y t klasave Alfa dhe Beta. Pastaj, prmes komandave:
X.Jeta(); Y.Dita(); X.Jeta();
dy her sht thirr funksioni Jeta dhe nj her funksioni Dita, t cilt prfshihen n komponentet e klasave prkatse. Rezultati i cili fitohet n ekran do t duket si ai q sht dhn n Fig.4.18.

classT1a
Nga kjo shihet se, si rezultat i thirrjes dy her t funksionit Jeta, vlerat q prcaktohen brenda klass Alfa jan shtypur dy her. N shembullin e dhn, deklarimi i objektit X n programin kryesor sht i panevojshm, sepse pjesa publike e klass Alfa prfshihet n klasn Beta. Kshtu, programi kryesor mund t shkruhet edhe si n vijim.
int main() { Beta Y; Y.Jeta(); Y.Dita();

Y.Jeta(); return 0; }
Definimi i funksioneve jasht klasave

Me qllim t rritjes s dukshmris s klasave, funksionet q shfrytzohen brenda tyre edhe n kt rast mund t definohen jasht strukturave t tyre, duke i shfrytzuar format e zakonshme. Shembull Versioni classT1b i programit classT1a, n t cilin definimi i funksioneve bhet jasht strukturave t klasave.
// Programi classT1b #include <iostream> using namespace std;
class Alfa { private: int a; public: double b; void Jeta(); }; class Beta:public Alfa { private: double c; public: int d; void Dita(); };
int main() { Beta Y; Y.Jeta(); Y.Dita(); Y.Jeta(); return 0;
Klasat 197
}
void Alfa::Jeta() { a=5; b=8; cout << "\nVlerat te klasa Alfa" << "\n\n a=" << a << "\n b=" << b << "\n\n"; } void Beta::Dita() { b=2; c=4; d=7; cout << "Vlerat te klasa Beta" << "\n\n b=" << b << "\n c=" << c << "\n d=" << d << "\n"; }
Shfrytzimi i antarve t mbrojtur

Antart e klass baz do t jen edhe t mbrojtur, duke e shfrytzuar specifikuesin e qasjes protected. Kta antar mund t shfrytzohen plotsisht njlloj si edhe antart t cilt prfshihen nn specifikuesin private. Por, pr dallim nga ata nn specifikuesin private, komponentet nn specifikuesin protected mund t shfrytzohen edhe te klasat e nxjerra (ato nn specifikuesin private nuk mund t shfrytzohen te klasat e nxjerra). Antarve t klass baz me specifikues t qasjes s mbrojtur nuk mund t'u qasemi nga jasht sikur edhe atyre me specifikues t qasjes private. Por, antart e klass, t cilt jan deklaruar si t mbrojtur, mund t shfrytzohen edhe brenda klasave t nxjerra, gj q nuk sht e mundur pr antart me specifikues t qasjes private. Shembull Versioni classT1c i programit classT1b, n t cilin variabla b sht prfshir nn specifikuesin e qasjes s mbrojtur.
// Programi classT1c #include <iostream> using namespace std; class Alfa { private: int a; protected: double b; public: void Jeta(); }; class Beta:public Alfa { private: double c; public: int d; void Dita(); }; int main() { Beta Y; Y.Jeta(); Y.Dita(); Y.Jeta(); return 0; }
Pjesa tjetr e programit, q nuk sht dhn, n t ciln prcaktohen funksionet Jeta dhe Dita, mbetet e njjt me at q shihet te programi classT1b. Kjo do t thot se variabla b n komponenten e mbrojtur t klass Alfa shfrytzohet edhe te klasa e nxjerr Beta. Nse ekzekutohet programi i dhn, rezultati do t jet i njjt me at q sht dhn n Fig.4.18.
Shfrytzimi i antarve gjat trashgimis

Antart e klass baz bhen edhe antar t klass s nxjerr. Te klasa e nxjerr mund t'u qasemi direkt antarve publik dhe antarve t mbrojtur t klass baz. Por, nuk lejohet qasja direkte tek antart e mbrojtur t klass baz,
Klasat 199 prej klass s nxjerr. Qasja direkte te antart privat t klass baz sht e mundshme vetm brenda klass baz. Antart publik t klass baz trashgohen te klasa e nxjerr si antar publik, kurse antart privat ose t mbrojtur, varsisht nga specifikuesi i qasjes q zgjedhet gjat definimit t klass s nxjerr, ashtu si sht dhn n vijim.
1.
class Alfa { ... }; class Beta: public Alfa { ... };
Ktu, antart publik t klass Alfa trashgohen te klasa e nxjerr Beta si antar publik.
2.
class Alfa { ... }; class Beta: private Alfa { ... };
N kt rast, antart publik t klass Alfa te klasa e nxjerr Beta trashgohen si antar privat.
3.
class Alfa { ... }; class Beta: Alfa { ... };
Meq ktu nuk sht shnuar specifikuesi i qasjes, kompjuteri e nnkupton at si private. Prandaj, n kt rast, si edhe n rastin paraprak, antart publik t klass Alfa trashgohen si antar privat te klasa e nxjerr Beta.
4.
class Alfa { ... }; class Beta: protected Alfa { ... };
N kt rast, pasi specifikuesi i qasjes pr antart e trashguar sht

protected, antart publik t klass Alfa do t jen antar t mbrojtur te klasa e nxjerr Beta.
Pas definimit t klass s nxjerr, vlejn rregullat e qasjes pr klasat e zakonshme, si tek antart e saj, ashtu edhe tek antart e trashguar nga klasa baz, gj q n form prmbledhse shihet te tabela e cila sht dhn n Fig.4.19. Specifikuesi i qasjes
public private protected
Qasja brenda klass baz po po po
Qasja brenda klass s nxjerr po jo po
Qasja jasht klass po jo jo
Fig.4.19 Mundsit e qasjes tek antart e klasave Klasa baz nuk ka qasje tek antart e klass s nxjerr, prkatsisht prej saj nuk mund t shihen komponentet e pjess tjetr t hierarkis s klasave n t ciln ajo prfshihet. N literatur pr klasn baz dhe pr klasn e nxjerr shfrytzohen edhe termat klas prind dhe klas fmij, ose edhe superklas dhe subklas. do klas e nxjerr bhet klas baz pr klasat t cilat nxirren prej saj.
Ridefinimi i funksioneve t klass baz

Funksionet n komponentet publike t klass baz mund t ridefinohen te klasat e nxjerra prej saj. Prkatsisht, n klasn e nxjerrur mund t ridefinohen funksione me emra t njjt, numr dhe tip t njjt t parametrave. Por, ky ridefinim i funksioneve vlen vetm pr klasn e nxjerr dhe jo edhe pr klasn baz. Shembull Programi classT2, prmes s cilit tregohet ridefinimi te klasa e nxjerr Beta i funksionit Nata, prmes s cilit te klasa Alfa
Klasat 201 llogaritet vlera e shprehjes:

g = 3a + 2b 1
kurse te klasa e nxjerr Beta vlera n fjal llogaritet me shprehjen:

g = 2b + 3c d
// Programi classT2 #include <iostream> using namespace std; class Alfa { public: double a,b,g; Alfa(); void Nata(); }; class Beta:public Alfa { private: double c; public: int d; Beta(); void Nata(); }; int main() { Alfa X; Beta Y; X.Nata(); cout << "\nVlera e llogaritur te klasa Alfa g=" << X.g; Y.Nata(); cout << "\n\nVlera e llogaritur te klasa Beta g=" << Y.g << "\n\n"; return 0; } Alfa::Alfa() { a=5; b=8;

} Beta::Beta() { c=4; d=7; cout << << << << << << << << << << }
"\nVlerat e variablave" "\n\n a=" a "\n b=" b "\n c=" c "\n d=" d "\n";
void Alfa::Nata() { g=3*a+2*b-1; } void Beta::Nata() { g=2*b+3*c-d; }
Llogaritja e vlers s variabls g, si n klasn baz Alfa ashtu edhe n klasn e nxjerr Beta, sht definuar brenda funksionit Nata, i cili prfshihet n komponentet publike prkatse. Nse ekzekutohet programi i dhn, rezultati q fitohet n ekran do t duket si n Fig.4.20.

classT2
Klasat 203
Trashgimia e shumfisht
Gjat krijimit t klasave prmes trashgimis, klasa e re mund t nxirret prej nj klase baz, ose edhe prej m shum klasave baz njkohsisht. N kto dy raste flitet pr trashgimi t njfisht (ang. single inheritance) dhe trashgimi t shumfisht (ang. multiple inheritance). Te shembujt q u dhan n pjesn paraprake kemi t bjm me trashgimin e njfisht, sepse antart e trashguar t klass s nxjerr jan antar t vetm nj klase baz, p.sh, ashtu si shihet n Fig.4.21.
Fig.4.21 Paraqitja skematike e trashgimis s njfisht
Ktu, klasa e nxjerr X i trashgon vetm antart e klass baz A, gj q, si sht dhn m par, n program shkruhet si n vijim.
class A { ... };
class X:public A { ... };
Specifikuesi i qasjes te klasa e nxjerr X, pr antart e trashguar nga klasa A, si u pa n shembujt paraprak, prve public, mund t jen edhe private dhe protected. Nj shembull i trashgimis s shumfisht, kur klasa X sht nxjerr nga dy klasat baz A dhe B, skematikisht mund t paraqitet si n Fig.4.22.
Fig.4.22 Paraqitja skematike e trashgimis s shumfisht
Gjat definimit t trashgimis nga shembulli n fjal, definimi i relacioneve t klasave do t duket si n vijim.
class A { ... }; class B { ... };
class X:public A,public B { ... };
Nnkuptohet se edhe ktu specifikuesit e qasjes te klasa e nxjerr X, pr antart e trashguar nga klasat A dhe B, si te rastet e trashgimis s njfisht, prve public, mund t jen edhe private dhe protected. Trashgimia e shumfisht mund t jet edhe komplekse, kur si klasa baz paraqiten edhe klasa t nxjerra, p.sh. si ajo q shihet n Fig.4.23.
Fig.4.23 Trashgimi e shumfisht komplekse N program, definimi i relacioneve t klasave n kt rast do t mund t shkruhej ashtu si sht dhn n vijim.
class A { ... };
Klasat 205
class B:public A { ... }; class C:public A { ... }; class X:public B,public C { ... };
Operatori i shoqrimit tek objektet

Nse n program jan deklaruar dy objekte x1 dhe x2 t klass x, prmes operatorit t shoqrimit:
x2=x1;
vlerat e variablave t komponenteve t objektit x1 u shoqrohen variablave prkatse t komponenteve t objektit x2. Shembull Programi classR1, prmes s cilit tregohet shoqrimi i vlerave t variablave t komponenteve t objektit kater1 t klass brinjet, variablave prkatse t komponenteve t objektit kater2.
// Programi classR1 #include <iostream> using namespace std; class brinjet {

private: double a,b; public: void vlerat(double x,double y); void shtypja(); }; int main() { brinjet kater1,kater2; kater1.vlerat(7.5,4.2); cout << "\nVlerat origjinale"; kater1.shtypja(); kater2=kater1; cout << "Vlerat e kopjuara"; kater2.shtypja(); return 0; } void brinjet::vlerat(double x,double y) { a=x; b=y; } void brinjet::shtypja() { cout << "\n\n a=" << a << "\n b=" << b << "\n\n"; }
N program, fillimisht jan deklaruar objektet kater1 dhe kater2 t klass brinjet. Me thirrjen e funksionit vlerat:
kater1.vlerat(7.5,4.2);
variablave a dhe b t objektit kater1 u shoqrohen vlerat 7.5 dhe 4.2. Pastaj, pasi shtypen kto vlera, duke e thirrur funksionin shtypja:
kater1.shtypja();
prmes operatorit t shoqrimit, i cili zbatohet mbi dy objektet:

kater2=kater1;
Klasat 207 vlerat e variablave t objektit kater1 u shoqrohen variablave prkatse t objektit kater2, prkatsisht vlerat e variablave t njrit objekt kopjohen te variablat prkatse t objektit tjetr. Kjo shihet edhe pas shtypjes s vlerave, duke e thirrur funksionin shtypja t objektit kater2:
kater2.shtypja();
gj q sht dhn n Fig.4.24.

classR1
Krahasimi i variablave t klass

Objektet nuk mund t krahasohen direkt mes vete. Por, mund t krahasohen vlerat e variablave t prfshira brenda tyre. Shembull Versioni classR2 i programit classR1, tek i cili krahasohen variablat brenda objekteve X dhe Y t klass brinjet.
Ktu sht ndryshuar programi kryesor dhe definicioni i klass (variablat a dhe b jan deklaruar si publike), ashtu si shihet n vijim, kurse pjesa e nnprogrameve mbetet sikurse q sht dhn te versioni classR1.
// Programi classR2 #include <iostream> using namespace std; class brinjet { public: double a,b; void vlerat(double x,double y); void shtypja(); };
int main() { brinjet X,Y; X.vlerat(7.5,4.2); Y.vlerat(6.3,4.2); cout << "\nVlerat n objektin X"; X.shtypja(); cout << "Vlerat n objektin Y"; Y.shtypja();
if ((X.a==Y.a) && (X.b==Y.b)) cout << "Vlerat jan t barabarta"; else cout << "Vlerat nuk jan t barabarta" << "\n\n"; return 0; }
Me pjesn e fundit t programit krahasohet barazia e variablave prkatse tek objektet X dhe Y. Meq gjat thirrjes s funksionit vlerat pr dy objektet e veanta:
X.vlerat(7.5,4.2); Y.vlerat(6.3,4.2);
variablave a dhe b u shoqrohen vlera t ndryshme, rezultati n ekran do t duket si n Fig.4.25.
Fig.4.25 Pamja e ekranit pas ekzekutimit t programit classR2
Klasat e ndrthurura
Klasat 209 Brenda klasave mund t definohen klasa t tjera, pr t krijuar struktura t klasave t ndrthurura. Te strukturat e tilla, klasa n t ciln prfshihet nj klas njihet si klas e jashtme, kurse klasa e prfshir n t njihet si klas e brendshme. Gjat ksaj, klasat e brendshme mund t vendosen n pjesn private ose n pjesn publike t klass s jashtme. Shembull Programi classN, n t cilin brenda komponentes publike t klass s jashtme Dita definohet klasa e brendshme Nata.
// Programi classN #include <iostream> using namespace std;
class Dita { private: void MesazhiA(); public: int a; void vleraA(int x); class Nata { private: void MesazhiB(); public: int b; void vleraB(int y); };
}; int main() { Dita Alfa; Dita::Nata Beta; Alfa.vleraA(55); cout << "\nVlera e variabls a=" << Alfa.a; Beta.vleraB(33); cout << "\nVlera e variabls b=" << Beta.b << "\n\n"; return 0; } void Dita::MesazhiA() {

cout << "\nKlasa e jashtme Dita\n"; } void Dita::vleraA(int x) { a=x; MesazhiA(); }
void Dita::Nata::MesazhiB() { cout << "\n\n\nKlasa e brendshme Nata\n"; } void Dita::Nata::vleraB(int y) { b=y; MesazhiB(); }
Ktu, gjat definimit t funksioneve t klass s brendshme dy her shfrytzohet operatori pr zbrthim t dukjes (::):
void Dita::Nata::MesazhiB() void Dita::Nata::vleraB(int y)
Gjithashtu, ky operator shfrytzohet edhe gjat deklarimit t objektit Beta t klass s brendshme Nata, n kt mnyr:
Dita::Nata Beta;
Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.4.26.

classN
Ktu, variablat a dhe b nuk mund t shfrytzohen te njra ose te klasa tjetr. Gjithashtu, emri i klass s brendshme Nata, meq nuk shihet jasht klass, mund t shfrytzohet si emr edhe i ndonj klase tjetr, jasht klasave t ndrthurura.
Klasat 211
Objektet brenda klasave

Brenda klasave mund t deklarohen dhe t shfrytzohen objekte t klasave t tjera. Deklarimi bhet n pjesn e antarve privat ose publik t klass. Shembull Programi classH1, n t cilin brenda komponentes private t klass Nata deklarohet objekti Alfa i klass Dita.
// Programi classH1 #include <iostream> using namespace std;
class Dita { private: void MesazhiA(); public: int a; void vleraA(int x); };
class Nata { private: void MesazhiB(); Dita Alfa; public: int b; void vleraB(int y); }; int main() { Nata Beta; Beta.vleraB(56); cout << "\n\n\nProgrami kryesor" << "\n\nVlera e variabls b: " << Beta.b << "\n\n"; return 0; } void Dita::MesazhiA() {

cout << "\nKlasa Dita\n"; } void Dita::vleraA(int x) { a=x; MesazhiA(); cout << "\nVlera e variabls a: " << a; } void Nata::MesazhiB() { cout << "\n\n\nKlasa Nata\n"; } void Nata::vleraB(int y) { b=y; Alfa.vleraA(78); MesazhiB(); cout << "\nVlera e variabls a: " << Alfa.a; }
N program, fillimisht sht definuar klasa Dita. Pastaj, brenda klass Nata sht deklaruar objekti Alfa i klass Dita, i cili shfrytzohet gjat thirrjes s funksionit vleraA:
Alfa.vleraA(78);
brenda funksionit vleraB, ku edhe shtypet vlera e variabls a, duke e shkruar brenda komands pr shtypje si Alfa.a, pasi fillimisht thirret funksioni MesazhiB. N programin kryesor deklarohet edhe objekti Beta i klass Nata, ku shtypet vlera e variabls b, duke e shkruar brenda komands pr shtypje si Beta.b, pasi fillimisht thirret funksioni:
Beta.vleraB(56);
Rezultati n ekran do t duket ashtu si sht dhn n Fig.4.27.
Klasat 213
Fig.4.27 Pamja e ekranit pas ekzekutimit t programit classH1
Fushat brenda klasave

N komponentet e klasave mund t prfshihen edhe fusha, p.sh., si jan vektort. Rezervimi i vendeve t nevojshme pr fushat (numri maksimal i mundshm i antarve t tyre) bhet prmes deklarimit si konstante para definimit t klasave. Por, njkohsisht brenda klasave, n komponente t veanta vendosen variablat te t cilat ruhen dimensionet aktuale t fushave. Shembull Programi classV1, prmes s cilit gjendet antari minimal n vektorin e dhn A(n), i cili prfshihet n komponenten e klass Vektori.
// Programi classV1 #include <iostream> #include <iomanip> using namespace std;
const int m=10;

class Vektori { public: int n; double A[m]; double Min(); }; int main() { int i; Vektori cout << << <<
Jeta = {6,3.2,14.5,-7.6,1.4,-3.2,8.3}; "\nAntart e vektorit\n" "\n i A[i]" "\n-------------------\n";
for (i=0;i<Jeta.n;i++) cout << setw(4)

<< i << setw(10) << Jeta.A[i] << "\n"; "-------------------\n" "\nVlera minimale x: " Jeta.Min() "\n\n";
cout << << << << return 0; }
double Vektori::Min() { double x=A[0]; int i; for (i=1;i<n;i++) if (A[i]<x) x=A[i]; return x; }
Programi i dhn sht nj verzion i modifikuar i programit t ngjashm, i cili sht dhn gjat shpjegimit t strukturave. Ktu, n vend t fjals struct sht shnuar fjala class, si dhe komponentet jan deklaruar si publike, duke e shnuar para tyre fjaln public:. Numri maksimal i mundshm i antarve t vektorit sht prcaktuar prmes komands:
const int m=10;
meq brenda klass vektori sht deklaruar kshtu:

double A[m];
Por, pasi gjat deklarimit t objekteve t klass n fjal mund t shfrytzohen vektor me numr t ndryshm antarsh, n pjesn me t dhna t saj sht shfrytzuar edhe variabla n, prmes s cils prcaktohet numri aktual i antarve t vektorit. N kt mnyr, gjat deklarimit t objektit Jeta t tipit vektor, n grumbullin me vlera, t cilat jan shnuar brenda kllapave:
Vektori Jeta = { 6,3.2,14.5,-7.6,1.4,-3.2,8.3};
vlera e par 6 i prket variabls n.
Klasat 215 Pr gjetjen e antarit minimal t vektorit A(n), prmes algoritmit t njohur, brenda klass sht definuar funksioni Min. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.4.28.

classV1
Fushat e objekteve
Grupet e t dhnave t nj klase t caktuar mund t vendosen n nj fush t objektit prkats. Gjat ksaj, n nj element t fushs prfshihen t dhna t cilat u prgjigjen komponenteve t klass n fjal. Shembull Programi classF1, prmes s cilit tregohet deklarimi si vektor me n-antar i objektit studenti t klass person.
// Programi structV2 #include <iostream> using namespace std;
class person { public: char emri[8],qyteti[10]; int viti; };

int main() { const int n=2; int i;
person studenti[n];
cout << "\nT dhnat nga tastiera\n\n"; for (i=0;i<n;i++) { cout << "Emri .....: "; cin >> studenti[i].emri; cout << "Qyteti ...: "; cin >> studenti[i].qyteti; cout << "Viti .....: "; cin >> studenti[i].viti; cout << "\n"; } cout << "\nT dhnat e lexuara\n"; for (i=0;i<n;i++) { cout << "\nEmri .....: " << studenti[i].emri; cout << "\nQyteti ...: " << studenti[i].qyteti; cout << "\nViti .....: " << studenti[i].viti << "\n"; } cout << "\n"; return 0; }
Edhe ky program paraqet nj verzion t modifikuar t programit t ngjashm, i cili sht dhn gjat shpjegimit t strukturave. N program sht parapar t lexohen t dhnat q ruhen n komponentet e klass person dhe pastaj t njjtat edhe t shtypen n ekran. Rezultati pas ekzekutimit t programit, p.sh., mund t duket ashtu si sht dhn n Fig.4.29.
Klasat 217
Fig.4.29 Pamja e ekranit pas ekzekutimit t programit classV2
Dukshmria e klasave dhe e objekteve

Antart e klass jan lokal dhe duken vetm brenda klass. Pr t'i shfrytzuar antart e klass jasht saj, duhet t shfrytzohet objekti i klass dhe pika si operator pr qasje tek antari i klass. Pr dukshmrin e objekteve vlejn principet e njohura pr dukshmrin e variablave lokale dhe globale.
4
Pointert
Deklarimi i pointerve Adresat e variablave Vlera n adresn e variabls Shoqrimi i vlerave Operatort inverz Llogaritjet prmes pointerve Operimi me vlerat e pointerve Pointert gjat operimit me fusha Fusha pointersh Pointert si parametra t funksioneve Pointert n funksione Pointert n struktura Pointert n objekte 218 220 222 224 227 231 239 242 265 267 279 286 289
Pr ruajtjen e t dhnave n memorien e kompjuterit shfrytzohen variablat. Kjo mundson q operimi me t dhna t bhet duke operuar me variablat n t cilat ruhen ato. Me qllim t rezervimit t hapsirs s nevojshme memoruese pr variablat, para se t shfrytzohen deklarohen tipet e tyre. Njkohsisht, do lokacioni n hapsirn memoruese t kompjuterit i shoqrohet nj numr, i cili e paraqet adresn e lokacionit. Nga ana tjetr, kompjuteri gjat operimit me t dhna i shfrytzon adresat e lokacioneve n t cilat ato jan vendosur, prkatsisht adresat e variablave prkatse. Por, q edhe programuesi t ket qasje n kto adresa, n gjuhn C++ shfrytzohen variabla t tipit tregues, ose, si thuhet ndryshe - variabla pointer (ang. pointer), ose shkurt vetm pointer. Kto variabla quhen kshtu, sepse prmes tyre merren adresat e variablave, prkatsisht vlerat q ruhen brenda tyre tregojn te variablat. Kur flitet pr pointert, mund t shtrohet pyetja e arsyeshmris s prdorimit t tyre, prkatsisht e adresave t variablave, kur mund t operohet direkt me vet variablat. Pointert, n raste t caktuara kan nj prparsi, sepse prmes adresave, pa kufizime, mund t shfrytzohen vlerat e variablave n pjes t ndryshme t programit.
Deklarimi i pointerve
Pointert, si edhe variablat e tipeve t tjera, para se t shfrytzohen duhet t deklarohen. Ky deklarim u prngjan deklarimeve t variablave t zakonshme. Por ktu, pr t'i dalluar nga variablat e zakonshme, para pointerve shnohet simboli *, gj q n form t prgjithshme duket: t *p; ku jan:
p - variabla e tipit pointer. t - tipi i variabls p
Tipi t i variabls p duhet t prputhet me tipin e variabls adresa e s cils do t ruhet n t. Kshtu, p.sh., prmes komands:
int *a;
Pointert 219 deklarohet variabla a e tipit pointer, e cila tregon n nj variabl t tipit int. Gjat deklarimit, simboli * mund t shkruhet kudo mes tipit dhe variabls, p.sh., n njrn nga kto forma:
int *a; int * a; int * int* a;
a;
Meq deklarimet, kur simboli * shnohet larg variabls, mund t shkaktojn konfuzion, zakonisht praktikohet q ai t shkruhet pran variabls, ose pran tipit t variabls, ashtu si shihet n shembullin e par dhe n shembullin e fundit t dhn m sipr. Si tipe t variablave pointer shfrytzohen t gjith tipet e variablave t zakonshme. Kshtu, psh., si pointer mund t deklarohen variabla t cilat tregojn n variabla t tipeve int, double, char etj., n kt mnyr:
int *z; double *k; char *h;
ku, prmbajtja e variabls z tregon te nj variabl, prkatsisht lokacion memorues t tipit int, prmbajtja e variabls k tregon n nj variabl t tipit double, kurse prmbajtja e variabls h tregon n nj variabl t tipit char. N nj pointer t tipit int mund t ruhen vetm adresa t variablave t tipit int, gj q vlen edhe pr tipet e tjera t pointerve. Ngjashm si edhe gjat deklarimit t variablave t zakonshme, n nj deklarim njkohsisht mund t prfshihen disa variabla t tipit pointer, p.sh., kshtu:
int *g,*h;
Gjithashtu, bashk me variablat e tipit pointer mund t prfshihen edhe deklarime t tipeve t zakonshm t variablave. Kshtu, p.sh., variablat e dy deklarimeve t veanta:
int x,y; int *h,*p;
mund t prfshihen n nj deklarim t vetm:

int x,y,*h,*p;
220 Programimi i orientuar n objekte ku dy variablat e para x dhe y paraqesin variabla t zakonshme, kurse dy t fundit h dhe p - variabla t tipit pointer. Rekomandohet q gjat deklarimit t variablave t tipit pointer ato t inicializohen me vlern zero, si null pointer, p.sh., kshtu:
int *x=0;
ose duke e shfrytzuar konstanten zero (NULL):

int *x=NULL;
N fakt, lejohet inicializimi direkt i pointerve vetm me vlern zero. Kurse, nse tentohet q inicializimi direkt t bhet me ndonj vler tjetr, kompjuteri do t na lajmroj gabim. Mosinicializimi i pointerit me nj vler t caktuar paraqet rrezik, sepse vlera e fardoshme e tij mund t tregoj edhe n hapsirn e pjess me programe t kompjuterit, ashtu q ndryshimi i t dhnave q ruhen n kt hapsir mund t shkaktoj dme serioze softverike.
Adresat e variablave
Duke e shfrytzuar operatorin &, prmes shprehjes s forms:
p=&v;
adresa e variabls s zakonshme v vendoset te variabla p e tipit pointer. Shembull Programi point1, prmes s cilit tregohet marrja dhe shtypja e adress s variabls x, duke e shfrytzuar pointerin a.
// Programi point1 #include <iostream> using namespace std; int main() { int *a,x; x=357; cout << "\nVlera e variabls x: " << x << "\n"; a=&x;
Pointert 221
cout << "\nAdresa te pointeri a: " << a << "\n\n"; return 0; }
Fig.5.1 Pamja e ekranit pas ekzekutimit t programit point1 Si shihet nga figura e dhn, ktu fillimisht sht shtypur vlera e variabls
x dhe pastaj edhe adresa e saj. Kjo adres ruhet te pointeri a dhe sht marr prmes operatorit &, duke e shfrytzuar shprehjen: a=&x;
Pamja e pjess s hapsirs memoruese, ku vendosen t dhnat, pas secilit nga deklarimet vijuese:
1. 2. 3. int *a,x; x=357; a=&x;
do t duket si n Fig.5.2.
1.
00000000 00000001 ... 0012FEC8 ... 0012FED4 ...
2.
3.
357
357 0012FEC8
x a
Fig.5.2 Pamja e hapsirs memoruese pas secils nga sekuencat e tri komandave Me deklarimin e par, n memorie rezervohen vende pr variabln x (n adresn 0012FEC8) dhe pr pointerin a (n adresn 0012FED4). Pas komands s dyt, n hapsirn memoruese prkatse regjistrohet numri 357, i cili n fakt e paraqet vlern q i shoqrohet variabls x. Kurse, pas komands s tret, te
222 Programimi i orientuar n objekte hapsira memoruese q i prket pointerit a vendoset adresa 0012FEC8, e cila i prket variabls x.
Vlera n adresn e variabls

Nse dihet adresa e nj variable, prmes procesit t deadresimit ose t dereferimit (ang. dereferencing), mund t merret vlera e variabls. Pr kt qllim shfrytzohet operatori *, kshtu:
v=*p;
pas s cils, te variabla v do t vendoset vlera e variabls adresa e s cils ruhet te pointeri p. Shembull Programi point2, prmes s cilit tregohet shtypja e vlers s variabls ndrmjetsuese h, duke e shfrytzuar adresn e variabls g, e cila ruhet te pointeri a.
// Programi point2 #include <iostream> using namespace std; int main() { int *a,g,h; g=357; cout << "\nVlera e variabls g: " << g << "\n"; a=&g; cout << "\nAdresa te variabla a: " << a << "\n"; h=*a; cout << "\nVlera e variabls h: " << h << "\n\n"; return 0; }
Pointert 223 N program, prmes shprehjes:

a=&g;
te pointeri a ruhet adresa e variabls g. Pastaj, duke e shfrytzuar shprehjen:

h=*a;
te variabla h vendoset vlera e variabls, adresa e s cils ruhet te pointeri a, prkatsisht vlera e variabls g. Pas ekzekutimit t programit t dhn, rezultati n ekran do t duket si n Fig.5.3.
Fig.5.3 Pamja e ekranit pas ekzekutimit t programit point2 Prej ktu shihet se te variabla h ruhet vlera e variabls g, duke e prcjell at prmes adress e cila ruhet te pointeri a. Pamja e hapsirs memoruese prkatse pas sekuencs s komandave:
1. 2. 3. g=357; a=&g; h=*a;
1.
00000000 00000001 ... 0012FEBC ... 0012FEC8 ... 0012FED4 ...
2.
3.
357 357 357 0012FEC8 357 0012FEC8
h g a
Fig.5.4 Pamja e hapsirs memoruese pas sekuencs s tri komandave Prmes komands s par g=357, te lokacioni me adres 0012FEC8, vendoset vlera 357. Pastaj, pas komands s dyt a=&g, adresa e variabls g vendoset te pointeri a. N fund, me komandn e tret h=*a, te variabla h vendoset vlera, e cila gjendet n adresn q ruhet te pointeri a.
Shoqrimi i vlerave
Variablave t tipeve t zakonshm, me ndrmjetsimin e pointerve, n t cilt ruhen adresat prkatse, mund t'u shoqrohen vlera t konstanteve, ose vlera t variablave t tjera.
Shoqrimi i vlerave t konstanteve

Variabls, adresa e s cils ruhet te pointeri p, mund t'i shoqrohet nj vler konstante k edhe n rrug indirekte, kshtu: *p=k; Shembull Programi point3a, prmes s cilit tregohet vendosja indirekte e vlers 649, te variabla x, duke e shfrytzuar adresn e variabls x, e cila ruhet te pointeri a.
// Programi point3a #include <iostream> using namespace std; int main() { int x=837,*a; cout << "\nVlera fillestare e variabls x: " << x; a=&x; cout << "\n\nAdresa e variabls x te pointeri a: " << a << "\n"; *a=649; cout << "\nVlera e ndryshuar e variabls x: " << x << "\n\n"; return 0; }
Ktu, fillimisht, te pointeri a ruhet adresa e variabls x. Pastaj, pasi shtypet vlera fillestare e variabls x dhe adresa e cila ruhet te pointeri a, prmes shprehjes:
*a=649;
Pointert 225 te variabla x vendoset vlera e re 649, gj q shihet edhe te rezultati q shtypet n ekran (Fig.5.5).
Fig.5.5 Pamja e ekranit pas ekzekutimit t programit point3a Pamja prkatse e hapsirs memoruese pas sekuencs s komandave:
1. 2. 3. int x=837,*a; a=&x; *a=649;
1.
00000000 00000001 ... 0012FEC8 ... 0012FED4
2.
3.
0012FED4 837 837
0012FED4 649
a x
Fig.5.6 Pamja e hapsirs memoruese pas sekuencs s tri komandave Prmes komands s par n sekuencn e dhn, te lokacioni q i prket variabls x (lokacioni me adres 0012FED4), vendoset vlera 837. Pastaj, me komandn a=&x, adresa e variabls x vendoset te lokacioni i rezervuar pr pointerin a. N fund, duke e shfrytzuar komandn *a=649, n lokacionin me adres 0012FED4 (lokacionin, adresa e t cilit ruhet te pointeri a), vendoset vlera 649.
Shoqrimi i vlerave t variablave

Variabls, adresa e s cils ruhet te pointeri p, mund t'i shoqrohet vlera e variabls tjetr v n rrug indirekte, duke e shfrytzuar shprehjen: *p=v;
226 Programimi i orientuar n objekte Shembull Programi point3b, prmes s cilit tregohet vendosja indirekte e vlers s variabls x te variabla y, duke e shfrytzuar adresn e variabls y, e cila ruhet te pointeri a.
// Programi point3b #include <iostream> using namespace std; int main() { int x=837,y,*a; cout << "\nVlera e variabls x: " << x; a=&y; cout << "\n\nAdresa e variabls y: " << a << "\n"; *a=x; cout << "\nVlera e variabls y: " << y << "\n\n"; return 0; }
Rezultati i cili fitohet n ekran pas ekzekutimit t programit t dhn do t duket si n Fig.5.7.
Fig.5.7 Pamja e ekranit pas ekzekutimit t programit point3b Si shihet nga rezultati i fituar, variabls y i sht shoqruar vlera e variabls x. Pr kt qllim, te pointeri a ruhet adresa e variabls x, duke e shfrytzuar shprehjen:
a=&y;
Pointert 227 Pastaj, prmes shprehjes:

*a=x;
me ndrmjetsimin e adress s variabls y, te kjo variabl prcillet vlera e variabls x. Pamja e hapsirs memoruese n kt rast do t jet e ngjashme me at q u tregua m sipr, prmes tabels q shihet n Fig.5.6.
Operatort inverz
Operatort & dhe * mes vete llogariten si operator inverz, gj q vrtetohet edhe prmes shembujve t programeve q jan dhn n vijim. Shembull Programi point7, n t cilin te pointeri a ruhet adresa e variabls x. Pastaj shtypen dhe krahasohen vlerat x dhe *a.
// Programi point7 #include <iostream> using namespace std; int main() { int x,*a; a=&x; x=837; cout << << << << << << cout << "\nMeq:" "\n\nVlera x: " x "\nVlera *a: " *a "\n"; "\nRezultati i krahasimit sht ";
if (x == *a) cout << "true"; else cout << "false"; cout << "\n\n"; return 0; }
228 Programimi i orientuar n objekte N program, prmes shprehjes:

a=&x;
fillimisht, adresa e variabls x vendoset te pointeri a. Pastaj, pasi shtypet vlera e variabls x dhe vlera *a, duke e shfrytzuar komandn:
if (x == *a)
kto dy vlera krahasohen. Meq variabla a sht pointer n t cilin ruhet adresa e variabls x, prmes *a merret vlera e variabls x. Prandaj, raporti i vlerave q krahasohen me komandn if n fjal, do t jet true, gj q qart shihet n rezultatin q fitohet n ekran pas ekzekutimit t programit (shih Fig.5.8).
Fig.5.8 Pamja e ekranit pas ekzekutimit t programit point7 N program mund t shfrytzohen edhe kombinimet e operatorve * dhe
&.
Shembull
Programi pointX1, n t cilin te pointeri a ruhet adresa e variabls x. Pastaj shtypen vlerat e t gjitha kombinimeve t mundshme t operatorve & dhe *.
// Programi pointX1 #include <iostream> using namespace std; int main() { int x,*a; x=453; a=&x; cout << "\n a=&x: << a; x=*a; cout << "\n\n x=*a: << x;
"
"
Pointert 229
a=&*a; cout << "\n\n a=&*a: " << a; x=*&x; cout << "\n\n x=*&x: " << x; a=*&a; cout << "\n\n a=*&a: " << a << "\n\n"; return 0; }
Rezultati, i cili shtypet n ekran pas ekzekutimit t programit t dhn, do t duket si n Fig.5.9.

pointX1
Ktu, prmes kombinimit t operatorve *&, te shprehja a=*&a, n fakt merret adresa e variabls x q ruhet te pointeri a. Kjo duket m e qart, nse shfrytzohet forma e shprehjes *(&a), ku me &a nnkuptohet adresa e pointerit a, kurse me operatorin * para saj, nga adresa n fjal merret vlera, prkatsisht adresa q ruhet te pointeri a. Ngjashm, adresa a e variabls x merret edhe prmes kombinimit t operatorve &* te shprehja a=&*a. Si m sipr mund t analizohet edhe kombinimi i operatorve *&, te shprehja x=*&x, prmes s cils merret vlera e variabls x. Nga rezultatet e fitura m sipr, si prfundim mund t nxirret se operatort & dhe *, gjat puns me pointer, jan operator inverz mes vete. Gjithashtu, si prmbledhse mund t shkruhen shprehjet e raporteve mes operatorve dhe adress a t variabls x:
a=&x x=*a a=&*a x=*&x a=*&a
Kombinimet e operatorve mund t shfrytzohen gjat shtypjes s adresave, gjat shfrytzimit t vlerave t variablave, ose dhe gjat krahasimit t tyre. Shembull Programi point8, n t cilin te pointeri a ruhet adresa e variabls x. Pastaj shtypen dhe krahasohen vlerat a e *&a, si dhe x e *&x.
// Programi point8 #include <iostream> using namespace std; int main() { int x,*a; x=837; a=&x; cout << << << << << << cout << "\nMeq" "\n\nVlera a: " a "\nVlera *&a: " *&a "\n"; "\nRezultati i krahasimit t par sht ";
if (a == *&a) cout << "true"; else cout << "false"; cout << << << << << << cout << "\n\nMeq" "\n\nVlera x: " x "\nVlera *&x: " *&x "\n"; "\nRezultati i krahasimit t dyt sht ";
if (x == *&x)
Pointert 231
cout << "true"; else cout << "false"; cout << "\n\n"; return 0; }

point8
Llogaritjet prmes pointerve

Gjat llogaritjeve t ndryshme, prve operimit direkt me variabla, mund t shfrytzohet edhe operimi me ndrmjetsimin e pointerve. Shembull Programi prmes s cilit, nse x>y gjendet shuma z e numrave x dhe y, prndryshe z llogaritet si diferenc e tyre. Vlerat e variablave x dhe y kompjuterit i jepen si vlera hyrse prmes tastiers.
a. Llogaritjet direkte
// Programi pointA1a #include <iostream> using namespace std; int main() { int x,y,z;
cout << "\nVlera e variabls x: "; cin >> x; cout << "\nVlera e variabls y: "; cin >> y; if (x>y) { z=x+y; cout << "\nRezultati i shums z=" << z; } else { z=x-y; cout << "\nRezultati i diferencs z=" << z; } cout << "\n\n"; return 0; }
Prmes programit t dhn, varsisht nga raporti i vlerave t variablave hyrse x dhe y, llogaritet shuma:
z=x+y;
prkatsisht diferenca e tyre:

z=x-y;
Ktu, si shihet nga shprehjet e dhna, gjat llogaritjeve jan shfrytzuar variablat e zakonshme x dhe y. Pr vlera hyrse t caktuara, rezultati n ekran do t duket ashtu si sht dhn n Fig.5.11.

pointA1a
Pointert 233
b. Llogaritjet prmes pointerve

// Programi pointA1b #include <iostream> using namespace std; int main() { int x,y,z,*a,*b; cout << "\nVlera e variabls x: "; cin >> x; a=&x; cout << "\nVlera e variabls y: "; cin >> y; b=&y; if (x>y) { z=*a+*b; cout << "\nRezultati i shums z=" << z; } else { z=*a-*b; cout << "\nRezultati i diferencs z=" << z; } cout << "\n\n"; return 0; }
Ktu, gjat llogaritjes s shums z jan shfrytzuar pointert prkats a dhe b t variablave x dhe y, si dhe shprehja:
z=*a+*b;
Njkohsisht, llogaritja e diferencs s dy vlerave hyrse x dhe y sht prcaktuar prmes shprehjes:
z=*a-*b;
ku n vend t variablave x dhe y jan shfrytzuar pointert prkats.
Nse ekzekutohet programi i dhn dhe prmes tastiers, si vlera hyrse kompjuterit i jepen numrat 4 dhe 7, rezultati n ekran do t duket si n Fig.5.12.

pointA1b
Pointert mund t shfrytzohen edhe gjat llogaritjeve brenda unazave t ndryshme. Shembull Programi prmes s cilit tregohet shfrytzimi i pointerit gjat llogaritjes s shums s t numrave natyror mes numrave 1 dhe n, por t cilt jan t plotpjestueshm me numrin x.
a. Llogaritja direkte
// Programi point9a #include <iostream> using namespace std; int main() { int i,n,x,k; double s=0; cout << "\nVlera e variabls n: "; cin >> n; cout << "\nVlera e variabls x: "; cin >> x; for (i=1;i<=n;i++) { k=i%x; if (k==0) s=s+i; } cout << "\nShuma e krkuar s=" << s << "\n\n"; return 0; }
Pointert 235 N program, pasi prmes tastiers kompjuterit t'i jepen vlerat e variablave
n dhe x, duke e shfrytzuar unazn for realizohet shtimi i antarve, t cilt e
prcaktojn vlern e shums. Por, me qllim t zgjedhjes s vlerave t variabls i q plotpjestohen me x, shfrytzohet shprehja:
k=i%x;
Kjo shprehje do t ket vlern 0 nse i plotpjestohet me x, gj q prdoret te komanda if pr degzimin prkats. Kshtu, p.sh., nse prmes tastiers kompjuterit si vlera hyrse pr variablat n dhe x i jepen numrat 32 dhe 5, rezultati n ekran do t duket si n Fig.5.13.

point9a
Ktu, vlera e shums sht llogaritur duke i shtuar antart q plotpjestohen me 5, kshtu:
s = 5 + 10 + 15 + 20 + 25 + 30 = 105
b. Llogaritje prmes pointerit

// Programi point9b #include <iostream> using namespace std; int main() { int i,n,x,k; double s,*a; a=&s; cout << "\nVlera e variabls n: "; cin >> n; cout << "\nVlera e variabls x: "; cin >> x; *a=0; for (i=1;i<=n;i++) { k=i%x;

if (k==0) *a=*a+i; } cout << "\nShuma e krkuar s=" << s << "\n\n"; return 0; }
N kt rast, n vend t shprehjeve pr vlern fillestare:

s=0;
dhe pr shtimin e antarve t shums:

s=s+i;
jan shfrytzuar shprehjet:

*a=0;
dhe
*a=*a+i;
Kshtu, gjat llogaritjes s shums, si para unazs ashtu edhe brenda saj, variabls s i qasemi prmes pointerit prkats a. Pas ekzekutimit t programit n fjal, rezultati n ekran nuk do t ndryshoj nga ai q u dha n Fig.5.13. Vlera e llogaritur mund t shihet si rezultat n ekran edhe nse kompjuterit i urdhrohet q ta shtyp vlern *a. Shembull Versioni point9c i programit paraprak, n t cilin sht urdhruar shtypja brenda unazs for e vlerave parciale t shums, duke i shtypur njkohsisht vlerat s dhe *a.
// Programi point9c #include <iostream> #include <iomanip> using namespace std; int main() { int i,n,x,k; double s,*a; char h[]="-------------------------"; a=&s;
Pointert 237
cout << "\nVlera e variabls n: "; cin >> n; cout << "\nVlera e variabls x: "; cin >> x; cout << "\n i s *a\n" << h << endl; *a=0; for (i=1;i<=n;i++) { k=i%x; if (k==0) { *a=*a+i; cout << setw(5) << i << setw(8) << s << setw(8) << *a << endl; } } cout << h << "\nShuma e krkuar s=" << s << "\n\n"; return 0; }
Pas ekzekutimit t programit t dhn, rezultati n ekran do t duket si n Fig.5.14.

point9c
238 Programimi i orientuar n objekte Si shihet nga rezultati, gjat shtimit t antarve t veant, shuma s dhe vlera *a jan t barabarta, sepse n fakt kemi t bjm me rritjen e vlers n lokacionin e njjt t memories. Edhe variabla e unazs mund t merret si pointer. Shembull Versioni point9d i programit paraprak, n t cilin n vend t variabls i t unazs shfrytzohet pointeri prkats j n kt variabl.
// Programi point9d #include <iostream> #include <iomanip> using namespace std; int main() { int i,*j,n,x,k; double s=0,*a; char h[]="-------------------------"; cout << "\nVlera e variabls n: "; cin >> n; cout << "\nVlera e variabls x: "; cin >> x; cout << "\n *j s *a\n" << h << endl; a=&s; j=&i; for (*j=1;*j<=n;*j=*j+1) { k=*j%x; if (k==0) { *a=*a+*j; cout << setw(5) << *j << setw(8) << s << setw(8) << *a << endl; } } cout << h << "\nShuma e krkuar s=" << s
Pointert 239
<< "\n\n"; return 0; }
Ktu, pr dallim nga verzionet paraprake t programit, para unazs sht shfrytzuar shprehja:
j=&i;
prmes s cils kompjuteri njoftohet se pointeri j do ta prmbaj adresn e variabls i, prkatsisht prmes kombinimit *j mund t merret vlera e variabls i. Por, duhet pasur kujdes n shfrytzimin e kombinimit *j, para se t prcaktohet vlera e variabls i, meq n momentin e shkruarjes s shprehjes n fjal kjo vler nuk sht prcaktuar. Nse ekzekutohet programi i dhn, pr vlerat hyrse q u shfrytzuan m sipr, rezultati do t jet i njjt me at q shihet n Fig.5.14, por n titull, n vend t variabls i, do t figuroj variabla *j.
Operimi me vlerat e pointerve

Vlerat e pointerve mund t rriten, t zvoglohen, t krahasohen, ose prmes operatorit t barazimit, ato vlera edhe mund t'u shoqrohen pointerve t tjer.
Rritja dhe zvoglimi i vlerave

Vlerat e pointerve mund t rriten ose t zvoglohen n rrug t zakonshme, duke shfrytzuar shprehje t formave:
p=p+k p=p-k
pas s cilave, pointeri p rritet ose zvoglohet pr kb bajt, ku b e paraqet numrin e bajtve pr pointerin e tipit t zgjedhur. Shembull Programi pointZ1, prmes s cilit tregohet rritja e vlers s pointerit a brenda nj unaze.
// Programi pointZ1 #include <iostream> using namespace std; int main() {

int i,x,*a; a=&x; cout << "\n i a" << "\n----------------" << "\n"; i=1; for (i=1;i<=6;i++) { cout << " " << i << " " << a << "\n"; a=a+1; } cout << "\n"; return 0; }
N program, prmes shprehjes a=a+1, e cila sht vendosur brenda unazs for, vlera e pointerit a rritet me hapin 1. Meq pointeri a sht i tipit int, prmes shprehjes n fjal, adresa q ruhet n pointer rritet pr 4 bajt. Kjo shihet edhe nga tabela e dhn n Fig.5.15, e cila shtypet gjat ekzekutimit t programit.

pointZ1
Ktu, vlera fillestare e adress 0012FEC8 e cila ruhet te pointeri a, sht e barabart me adresn e variabls x dhe prcaktohet me shprehjen:
a=&x;
Pas ksaj, prmes komands:

a=a+1;
adress a i shtohen 4 bajt:

0012FEC8 + 4
Pointert 241
--------0012FECC
Nnkuptohet se, nse variabla x zgjedhet e tipit double, edhe pointeri prkats a duhet t zgjedhet i tipit t njjt. Gjat ksaj, prmes shprehjes a=a+1, adresat e pointerit do t rriten nga 8 bajt, sepse t dhnat e tipit double ruhen n 8 bajt.
Shoqrimi dhe krahasimi i vlerave

Prmes operatorit t zakonshm t barazimit:
p=q
pointerit p mund t'i shoqrohet vlera e pointerit q, por vetm nse pointert jan t tipeve t njjt. Gjithashu, duke i shfrytzuar operatort prkats, prmes komands if mund t krahasohen mes vete vlerat e dy pointerve. Shembull Programi pointZ2, prmes s cilit tregohet barazimi dhe krahasimi i vlerave t pointerve p dhe q, pasi fillimisht te pointeri p t ruhet adresa e variabls x.
// Programi pointZ2 #include <iostream> using namespace std; int main() { double x,*p,*q; x=23.4; p=&x; cout << "\nAdresa te pointeri p: " << p; q=p; cout << "\n\nAdresa te pointeri q: " << q; if (p==q) cout << "\n\nPointert jan t barabart"; else cout << "\n\nPointert nuk jan t barabart"; cout << "\n\n"; return 0; }
Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si ai q sht dhn n Fig.5.16.
Fig.5.16 Pamja e ekranit pas ekzekutimit t programit pointZ2
N programin e dhn, krahasimi pr barazim mes pointerve mund t bhet edhe duke e shkruar komandn if n kt form:
if (p!=q) cout << "\n\nPointert nuk jan t barabart"; else cout << "\n\nPointert jan t barabart";
Gjithashtu, mund t shfrytzohen edhe operatort e tjer t krahasimit t pointerve, t cilt prdoren gjat krahasimit t variablave t zakonshme.
Pointert gjat operimit me fusha

Pr operim me antart e fushave mund t prdoren edhe pointert, ashtu si sht shpjeguar n vijim.
Operimi me antart e vektorve

Vektort mund t shfrytzohen duke i prdorur pointert, n t cilt ruhen adresat e antarve t tyre, ose vetm adresa e antarit t par, ku fillon vendosja e tyre n memorien e kompjuterit. Gjithashtu, gjat operimit me antart e vektorve prmes indekseve prkatse, edhe indekset mund t merren si pointer.
Pointert n antart e vektorve

Nse duam q gjat operimit, p.sh., me antart e vektorit v, atyre t'u qasemi me ndrmjetsimin e pointerit p, pr prcjelljen e adress s antarit t it te pointeri mund t shfrytzohet shprehja:
p=&v[i];
ku, p.sh., indeksi i e paraqet variabln e unazs prkatse.
Pointert 243 Shembull Programi pointA1, prmes s cilit tregohet shfrytzimi i pointerit a gjat shtypjes s antarve t vektorit Z(n).
// Programi pointA1 #include <iostream> #include <iomanip> using namespace std; int main() { const int n=5; int *a,i,Z[n]={27,12,-23,9,35}; char h[]="-----------------------------"; cout << "\n Indeksi << h << endl; Antari Adresa\n"
for (i=0;i<n;i++) { a=&Z[i]; cout << setw(6) << i << setw(10) << Z[i] << setw(12) << a << endl; } cout << h << "\n"; return 0; } Ktu, brenda unazs for sht vendosur shprehja: a=&Z[i];
prmes s cils adresa e antarit t i-t t vektorit vendoset te pointeri a. Njkohsisht, shtypen vlerat e variablave i, Z[i] dhe a, pr ta fituar tabeln me rezultate, e cila sht dhn n Fig.5.17. Fig.5.17 Pamja e ekranit pas ekzekutimit t programit pointA1
Si shihet nga tabela, antari i par sht vendosur tek adresa 0012FEA0, e cila ktu sht dhn n form heksadecimale. Pastaj, adresa e antarit t dyt rritet pr 4, prkatsisht gjendet prmes mbledhjes:
0012FEA0 + 4 ---------0012FEA4
Kjo sht rezultat i asaj se pr vendosjen e antarit t par A[0] t vektorit shfrytzohen 4-bajt, meq vektori sht deklaruar i tipit int. Ngjashm kompjuteri vepron edhe gjat zgjedhjes s adresave t antarve t tjer t vektorit. N hapsirn memoruese, antart e vektorit A vendosen ashtu si shihet n Fig.5.18.
00000000 00000001 ... 0012FEA0 0012FEA4 0012FEA8 0012FEAC 0012FEB0 ...
27 12 -23 9 35
Z[0] Z[1] Z[2] Z[3] Z[4]
Fig.5.18 Pamja e hapsirs memoruese pas vendosjes s antarve t vektorit
Pointeri n antarin e par t vektorit

Antarve t veant t vektorit v mund t'u qasemi prmes pointerit prkats p, edhe nse pointerit i shoqrohet adresa ku fillon vendosja e antarve t vektorit:
p=v;
e cila n fakt e paraqet adresn e antarit t par t tij. Shembull Versioni pointA2 i programit pointA1, tek i cili pr deklarimin e pointerit a si tregues n vektorin Z(n) shfrytzohet forma e par q u dha m sipr.
// Programi pointA2 #include <iostream>
Pointert 245
#include <iomanip> using namespace std; int main() { const int n=5; int *a,i,Z[n]={27,12,-23,9,35}; char h[]="-----------------------------"; cout << "\n Indeksi Antari << h << endl; a=Z; for (i=0;i<n;i++) { cout << setw(6) << i << setw(10) << Z[i] << setw(12) << a+i << endl; } cout << h << "\n"; return 0; } Adresa\n"
N fillim t programit, prmes komands:

a=Z;
te pointeri a prcillet adresa ku fillon vendosja e vektorit Z n memorien e kompjuterit. Si rezultat, p.sh., te pointeri do t ruhet adresa 0012FEA0, ku vendoset antari i par Z[0] i vektorit, gj q mund t vrtetohet nse shfrytzohet komanda pr shtypje t vlers s variabls a. Pas ksaj, rezultati i ekzekutimit t programit do t jet i njjt me at q u dha n Fig.5.17. Me qllim t shtypjes s adresave n t cilat fillon vendosja e antarve t veant t vektorit, te komanda pr shtypje, vlers fillestare t pointerit a i shtohet edhe indeksi i antarit prkats (a+i). Kjo do t thot se gjat rritjes s vlers s pointerit pr 1, adresa q ruhet n t rritet pr 4, gj q i prgjigjet numrit t bajtve n t cilt ruhet nj antar i vektorit, meq ai sht deklaruar i tipit int. Kshtu, p.sh., nse jemi pozicionuar tek antari i dyt i vektorit, pasi indeksi i tij sht 1, me rritjen pr 1 prmes shprehjes a+1, te pointeri a do t ruhet adresa 0012FEA8, e cila i prket antarit t tret Z[2] t
246 Programimi i orientuar n objekte vektorit. Kompjuteri vepron ngjashm edhe gjat zbritjes s vlers s pointerit, prkatsisht pas zbritjes a-1, kalohet n adresn e antarit paraprak t vektorit. Adresa e antarit t par t vektorit mund t vendoset te pointeri p, edhe nse shfrytzohet shprehja:
p=&v[0];
Kshtu, te shembulli i programit t dhn m sipr, pr inicializimin e pointerit a q t tregoj te vektori, prkatsisht tek antari i par i tij, n vend t komands:
a=Z;
duhet t shfrytzohet komanda:

a=&Z[0];
Pointeri n antarin e par t vektorit mund t shfrytzohet edhe gjat llogaritjeve t ndryshme n t cilat marrin pjes antart e vektorve. Shembull Programi pointL1, prmes s cilit tregohet shfrytzimi i pointerit a gjat llogaritjes s shums s antarve t vektorit R(n).
// Programi pointL1 #include <iostream> #include <iomanip> using namespace std; int main() { const int n=6; int *a,i,R[n]={15,8,4,17,6,29}; double s; char h[]="--------------------------------"; cout << "\n Indeksi Antari Shuma Adresa\n" << h << endl; a=&R[0]; s=0; for (i=0;i<n;i++) { s=s+*(a+i); cout << setw(6) << i << setw(8) << R[i]
Pointert 247
<< << << << << } cout << << << << return 0; } setw(7) s setw(10) &R[i] endl;
h "\nShuma prfundimtare s=" s "\n\n";
Nse ekzekutohet programi i dhn, rezultati q shtypet n ekran do t duket si n Fig.5.19, ku n dy kolonat e fundit t tabels jan shtypur vlerat e shumave parciale dhe adresat e antarve t vektorit.
Fig.5.19 Pamja e ekranit pas ekzekutimit t programit pointL1 N program, duke e shfrytzuar shprehjen:
a=&R[0];
pointeri a sht inicializuar me adresn e antarit t par t vektorit, q si shihet edhe m sipr, sht adresa 0012FE9C. Pastaj, brenda unazs n t ciln llogaritet shuma s, antart e veant t vektorit i shtohen shums, duke e shfrytzuar shprehjen:
s=s+*(a+i);
Ktu, n fakt, prmes pjess s shprehjes *(a+i), shums i shtohet vlera e antarit R[i], e cila gjendet n lokacionin me adres a+4i, ku numri 4 lidhet me at se pointeri sht deklaruar i tipit int dhe ka t bj me t dhna q ruhen n 4-bajt, ashtu si u shpjegua m par. Efekti i shprehjes n fjal sht i njjt sikur t shfrytzohej shprehja:

s=s+R[i];
Kshtu, p.sh., adresa e antarit t fundit t vektorit llogaritet duke ia shtuar adress 0012FE9C, n t ciln fillon vendosja e antarit t par, vlern heksadecimale 14 t numrit dhjetor 4i=45=20:
0012FE9C + 14 ---------0012FEB0
Indekset si pointer
Indekset e antarve t vektorve mund t shfrytzohen pr prcaktimin e pointerve n antart e tyre, pa prdorur nj variabl t veant t tipit pointer. Shembull Programi pointL2, prmes s cilit tregohet shfrytzimi i pointerit a gjat radhitjes s antarve t vektorit R(n) sipas madhsis, prej antarit m t madh kah ai m i vogli.
// Programi pointL2 #include <iostream> #include <iomanip> using namespace std; int main() { const int n=6; int i,j,*a,x,R[n]={15,8,4,17,6,12}; cout << "\nVektori i paradhitur\n" << "\n R={"; for (i=0;i<n;i++) cout << setw(4) << R[i]; cout << " }\n"; a=&R[0]; for (i=1;i<n-1;i++) for (j=i+1;j<n;j++) if (*(a+i) < *(a+j)) { x=*(a+i); *(a+i)=*(a+j); *(a+j)=x; }
Pointert 249
cout << "\nVektori i radhitur\n" << "\n R={"; for (i=0;i<n;i++) cout << setw(4) << *(a+i); cout << " }\n\n"; return 0; }
Ktu, krahasimi i antarve t vektorit prmes komands if realizohet duke i shfrytzuar adresat prkatse, t cilat prcaktohen prmes adress s antarit t par t tij, e cila ruhet te pointeri a. Pr kt qllim shfrytzohen indekset e tyre i dhe j, prkatsisht variablat e dy unazave, brenda s cilave krahasohen antart e vektorit. Varsisht nga rezultati i krahasimit, n hapsirn memoruese ndrrohen vendet e antarve q krahasohen, me ndrmjetsimin e variabls x. Rezultati q shtypet n ekran pas ekzekutimit t programit t dhn do t duket si n Fig.5.20.
Fig.5.20 Pamja e ekranit pas ekzekutimit t programit pointL2 Gjat shfrytzimit t indekseve t antarve t vektorve pr prcaktimin e pointerve n vlerat e tyre, mund t prdoret edhe nj variabl e veant e tipit pointer. Shembull Programi pointL3, prmes s cilit gjendet shuma s e antarve t vektorit R(n) me indeks tek, nse gjat llogaritjes edhe indekset deklarohen si pointer.
// Programi pointL3 #include <iostream> #include <iomanip> using namespace std; int main() {

const int n=6; int *a,i,*k,R[n]={15,8,4,17,6,29}; double s; char h[]="------------------------------"; cout << "\n Indeksi << h << endl; a=&R[0]; s=0; for (i=1;i<n;i=i+2) { k=&i; s=s+*(a+*k); cout << << << << << << << } cout << << << << return 0; } setw(6) i setw(10) R[*k] setw(12) s endl; Antari Shuma\n"
h "\nShuma prfundimtare s=" s "\n\n";
Ktu, te shprehja pr llogaritjen e shums:

s=s+*(a+*k);
n vend t indeksit, sht shfrytzuar pointeri k n indeksin i. Pointeri k inicializohet brenda unazs, sepse inicializimi jasht unazs mund t bhet vetm pr pointerin e vektorit. Pas ekzekutimit t programit t dhn, rezultati n ekran do t duket si n Fig.5.21.
Fig.5.21
Pointert 251 Pamja e ekranit pas ekzekutimit t programit pointL3
Pointert pa i deklaruar
Operimi me antart e vektorve mund t bhet edhe me kombinimin e operatorve *&, pa e deklaruar ndonj pointer t veant. Shembull Programi pointL4, prmes s cilit gjendet antari m i vogl x n vektorin e dhn R(n), duke e shfrytzuar kombinimin e operatorve *&.
// Programi pointL4 #include <iostream> #include <iomanip> using namespace std; int main() { const int n=6; int i,x,R[n]={15,8,4,17,6,12}; char h[]="----------------------"; cout << "\n Indeksi << h << endl; for (i=0;i<n;i++) cout << setw(5) << i << setw(12) << R[i] << endl; cout << h << endl; x=*&R[0]; for (i=1;i<n;i++) if (*&R[i] < x) x=*&R[i]; cout << "Antari m i vogl x=" << x << "\n\n"; return 0; } Antari\n"
Ktu, prmes shprehjes s forms:
x=*&R[0];
variabls x i shoqrohet vlera e antarit t par t vektorit, sepse me &R[0] merret adresa e antarit n fjal, kurse me *&R[0] - vlera e tij. Ngjashm kompjuteri e nnkupton edhe shprehjen *&R[i], e cila paraqitet dy her brenda unazs. Pas ekzekutimit t programit, rezultati n ekran do t duket ashtu si sht dhn n Fig.5.22.

pointL4
Edhe variablat e unazave mund t prcaktohen me kombinimin e operatorve *&. Shembull Programi pointL5, prmes s cilit gjendet numri k i antarve tek t vektorit F(n), duke e shfrytzuar pr t gjitha variablat kombinimin e operatorve *&.
// Programi pointL5 #include <iostream> #include <iomanip> using namespace std; int main() { const int n=6; int i,k,F[n]={17,8,11,5,10,3}; char h[]="---------------------"; cout << "\n Indeksi << h << endl; Antari\n"
*&k=0; for (*&i=0;*&i<n;*&i=*&i+1) {
Pointert 253
if((*&F[*&i]%2) != 0) *&k=*&k+1; cout << setw(6) << *&i << setw(10) << F[ *&i] << setw(12) << endl; } cout << << << << return 0; } h "\nNumri i antarve tek k=" k "\n\n";
Edhe n kt program nuk sht deklaruar asnj pointer. Por, pointert shfrytzohen duke i futur n prdorim kombinimet e operatorve *&, prfshir edhe variabln e unazs. Rezultati n ekran, pas ekzekutimit t programit t dhn, do t duket si n Fig.5.23.

pointL5
Nse n programin e msiprm duam q t shtypen vetm antart tek t vektorit, unaza prkatse do t shkruhet:
for (*&i=0;*&i<n;*&i=*&i+1) if((*&F[*&i]%2) != 0) { *&k=*&k+1; cout << setw(6) << *&i << setw(10) << F[*&i] << setw(12) << endl; }
Pas ktyre ndryshimeve, rezultati n ekran do t duket ashtu si shihet n Fig.5.24.

pointL5 me ndyshimet e theksuara
Operimi me antar t matricave

Gjat operimit me antart e matricave, si edhe te vektort, mund t shfrytzohen pointert n t cilt ruhen adresat e antarve, ose vetm adresat e antarve t par t tyre, n t cilat fillojn vendosjet e matricave n memorien e kompjuterit. Gjithashtu, edhe indekset e antarve t matricave mund t merren si pointer, me ndrmjetsimin e variablave t veanta t tipit pointer, ose edhe direkt. N vijim, prmes shembujve, do t tregohen opcionet e mundshme t shfrytzimit t pointerve gjat operimit me antart e matricave.
Shtypja e antarve t matricave

fardo operacioni q t ndrmerret mbi antart e matricave, patjetr duhet t shfrytzohen dy unaza t veanta, prmes s cilave prcaktohen indekset e antarve t tyre. Gjat shtypjes s antarve t matricave, me qllim q matricat n ekran ta ken pamjen e zakonshme, pas shtypjes s do rreshti t tyre duhet t urdhrohet kalimi n nj rresht t ri. Shembull Versione t programit prmes s cilit shtypen antart e matrics s dhn A(m,n), t shkruar n form t zakonshme dhe n format e tjera t mundshme me prdorim t pointerve.
a. Forma e zakonshme
// Programi pointM1a #include <iostream> #include <iomanip> using namespace std;
Pointert 255
int main() { const int m=3,n=4; int A[m][n]={{5,4,7,-2}, {3,1,-4,9}, {1,2,-3,6}}; int i,j; cout << "\n Matrica A\n\n"; for (i=0;i<m;i++) { for (j=0;j<n;j++) { cout << setw(5) << A[i][j]; } cout << endl; } cout << "\n"; return 0; }
Rezultati n ekran, pas ekzekutimit t programit t dhn, do t duket si n Fig.5.25.

pointM1a
b. Pointeri n antarin e par t matrics Sikurse te vektort, edhe te matricat mund t operohet me antart e tyre, duke e shfrytzuar pointerin i cili tregon n antarin e par t saj. Kshtu, p.sh., adresa e antarit t par t matrics v mund t vendoset te pointeri p, nse shfrytzohet shprehja:
p=&v[0][0];
Shfrytzimi i pointerit n fjal, i shnuar si a, shihet n versionin vijues t programit pr shtypje t matrics R.
// Programi pointM1b #include <iostream> #include <iomanip> using namespace std; int main() { const int m=3,n=4; int A[m][n]={{5,4,7,-2}, {3,1,-4,9}, {1,2,-3,6}}; int i,j,k=0,*a; cout << "\n Matrica A\n\n"; a=&A[0][0]; for (i=0;i<m;i++) { for (j=0;j<n;j++) { cout << setw(5) << *(a+k); k=k+1; } cout << endl; } cout << "\n"; return 0; }
Ktu, pointeri a sht inicializuar fillimisht me adresn e antarit t par t matrics:

a=&A[0][0];
Pastaj, pr t'i shtypur vlerat e veanta t antarve t matrics, shfrytzohet shprehja:

cout << setw(5) << *(a+k);
ku k e paraqet numratorin e antarve t matrics. N fakt, me shprehjen *(a+k) kompjuterit i urdhrohet q ta shtyp vlern e cila gjendet tek adresa a, por e rritur pr k-her nga 4 bajt.
Pointert 257 Adresat e antarve t matrics R n memorien e kompjuterit, p.sh., mund t duken ashtu si sht dhn n Fig.5.26.
00000000 00000001 ... 0012FF1C 0012FF20 0012FF24 0012FF28 0012FF3C ... 0012FF40 0012FF44 0012FF48
5 4 7 -2 3 ... 2 -3 6
A[0][0] A[0][1] A[0][2] A[0][3] A[1][0]

...
A[2][1] A[2][2] A[2][3]
Fig.5.26 Pamja e hapsirs memoruese pas vendosjes s antarve t matrics Pas ekzekutimit t programit t dhn, rezultati do ta ket pamjen e njjt me at q sht dhn n Fig.5.25. c. Antart e matrics si pointer t padeklaruar
// Programi pointM1c #include <iostream> #include <iomanip> using namespace std; int main() { const int m=3,n=4; int A[m][n]={{5,4,7,-2}, {3,1,-4,9}, {1,2,-3,6}}; int i,j; cout << "\n Matrica A\n\n"; for (i=0;i<m;i++) { for (j=0;j<n;j++) { cout << setw(5) << *&A[i][j]; } cout << endl; } cout << "\n";

return 0; }
Ktu, nuk sht deklaruar asnj pointer, por gjat shtypjes s antarve t matrics shfrytzohet kombinimi i operatorve *&, efekti i t cilve sht shpjeguar m par. Edhe n kt rast, pas ekzekutimit t programit t dhn, rezultati q shtypet do t jet i njjt me at q u dha n Fig.5.25. d. T gjitha variablat si pointer t padeklaruar
// Programi pointM1d #include <iostream> #include <iomanip> using namespace std; int main() { const int m=3,n=4; int A[m][n]={{5,4,7,-2}, {3,1,-4,9}, {1,2,-3,6}}; int i,j; cout << "\n Matrica A\n\n"; for (*&i=0;*&i<m;*&i=*&i+1) { for (*&j=0;*&j<n;*&j=*&j+1) { cout << setw(5) << *&A[*&i][*&j] ; } cout << endl; } cout << "\n"; return 0; }
N fillim t programit, edhe n kt version asnj variabl nuk sht deklaruar si pointer. Por, gjat zgjedhjes s vlerave t variablave t unazave i e j, si dhe gjat shtypjes s antarve t matrics A shfrytzohen kombinimet e operatorve *&, ashtu si sht shpjeguar edhe m lart. Pas ekzekutimit t programit t dhn, rezultati do t duket si ai q sht dhn n Fig.5.25.
Gjetja e antarit t caktuar n matric

Nga antart e matrics s dhn mund t gjendet antari m i madh, antari m i vogl, antari m i vogl ose m i madh pr nga vlera absolute, ose edhe indekset e antarve n fjal. Gjithashtu, mund t gjenden antart n fjal
Pointert 259 n kufij t caktuar vlerash, p.sh., vetm n grumbullin e antarve me vlera pozitive, ose t antarve me vlera negative etj. Shembull Programi pointM2, prmes s cilit gjendet antari m i madh pr nga vlera absolute te matrica e dhn A(m,n), si dhe indekset prkatse (pozicioni i tij n matric).
// Programi pointM2 #include <iostream> #include <iomanip> using namespace std; int main() { const int m=3,n=4; int A[m][n]={{5,4,7,-2}, {3,1,-4,9}, {1,2,-3,6}}; int i,j,g,h,x; cout << "\n Matrica A\n\n"; x=abs(*&A[0][0]); g=0; h=0; for (i=0;i<m;i++) { for (j=0;j<n;j++) { if (abs(*&A[i][j]) > x ) { x=abs(*&A[i][j]); g=i; h=j; } cout << setw(5) << *&A[i][j]; } cout << endl; } cout << << cout << << "\nAntari me vler absolute m t madhe x=" x; "\nKy antar gjendet n rreshtin e " g+1

<< ". dhe kolonn e " << h+1 << ".\n\n"; return 0; }
N program, pr operim me antart e matrics shfrytzohet kombinimi i operatorve *&. Kurse indekset i dhe j t antarve t matrics jan shkruar si variabla t zakonshme. Rezultati n ekran, pas ekzekutimit t programit t dhn, do t duket ashtu si sht dhn n Fig.5.27.
Fig.5.27 Pamja e ekranit pas ekzekutimit t programit pointM2
Formimi i vektorit nga antart e matrics

Antart e matricave, ose vetm ato me vlera t caktuara, me qllim t shfrytzimit t mtejshm, mund t vendosen n vektor. Shembull Programi pointM3, prmes s cilit nga antart e matrics s dhn A(m,n) formohet vektori B, duke i marr vetm ata q jan m t mdhenj se 2 dhe m t vegjl se 8.
// Programi pointM3 #include <iostream> #include <iomanip> using namespace std; int main() { const int m=3,n=4; int A[m][n]={{5,4,7,-2}, {3,1,-4,9}, {1,2,-3,6}}; int i,j,k,B[m*n], *a,*b; cout << "\n Matrica A\n\n";
Pointert 261
k=-1; for (i=0;i<m;i++) { for (j=0;j<n;j++) { a=&A[i][j]; if ((*a>2) && (*a<8)) { k=k+1; b=&B[k]; *b=*a; } cout << setw(5) << *a; } cout << endl; } cout << "\nVektori i formuar" << "\n\nB={"; for (i=0;i<k;i++) cout << setw(4) << *&B[i]; cout << " }" << "\n\n"; return 0; }
N programin e dhn, gjat operimit me antart e matrics A dhe vektorit B jan shfrytzuar pointert a dhe b, t deklaruar n fillim t programit. Me qllim t prcjelljes s adresave t antarve t matrics A te pointeri a, brenda unazave sht shfrytzuar shprehja:
a=&A[i][j];
Pastaj, ky pointer sht prdorur te komanda if:

if ((*a>2) && (*a<8))
me qllim t zgjedhjes s antarve q kan vlera n kufijt mes vlerave 2 dhe 8. Kur gjendet nj antar q i plotson dy kushtet e dhna, s pari rritet numratori i antarve q prfshihen n vektor:
k=k+1;
262 Programimi i orientuar n objekte dhe pastaj, pr vendosjen e antarit t gjetur n vektor, s pari prcaktohet pointeri prkats:
b=&B[k];
dhe n adresn q ruhet te ky pointer, prcillet vlera e matrics A, duke e lexuar adresn prkatse te pointeri a:
*b=*a;
N fund t unazs s jashtme sht parapar shtypja e antarve t matrics A, me ndrmjetsimin e pointerit a:
cout << setw(5) << *a;
Gjat shtypjes s antarve t vektorit t formuar B n fund t programit shfrytzohet kombinimi i operatorve *&, n kt mnyr:
cout << setw(4) << *&B[i];
Nse ekzekutohet programi i dhn, rezultati n ekran do t duket ashtu si sht dhn n Fig.5.28.

pointM3
Shuma e antarve t matrics

Pointert mund t shfrytzohen edhe gjat llogaritjes s shums s t gjith antarve t matrics, ose t shums s antarve t caktuar t saj, duke i mbledhur vlerat reale t antarve, ose vlerat absolute t tyre. Shembull Programi pointM4, prmes s cilit gjendet shuma s e vlerave
Pointert 263 absolute t antarve t matrics s dhn A(m,n).
// Programi pointM4 #include <iostream> #include <iomanip> using namespace std; int main() { const int m=3,n=4; int R[m][n]={{5,4,7,-2}, {3,1,-4,9}, {1,2,-3,6}}; int i,j,k=0,s=0,*a; cout << "\n Matrica R\n\n"; a=&R[0][0]; for (i=0;i<m;i++) { for (j=0;j<n;j++) { cout << setw(5) << R[i][j]; s=s+abs(*(a+k)) ; k=k+1; } cout << endl; } cout << "\nShuma e llogaritur s=" << s << "\n\n"; return 0; }
N fillim t programit, prmes shprehjes:

a=&R[0][0];
te pointeri a vendoset adresa e antarit t par t matrics. Pastaj, pr shtimin e vlers absolute t antarve t matrics te variabla e shums s, shfrytzohet shprehja:
s=s+abs(*(a+k));
Ktu, prmes pjess s shprehjes abs(*(a+k)), shums i shtohet vlera absolute e antarit t k-t t matrics. Vlera e numratorit k n fakt i shtohet adress q ruhet te pointeri a, e shumzuar me 4 (aq sa bajt shfrytzohen pr vendosjen e antarve t matrics, meq jan zgjedhur t tipit int). Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.5.29.

pointM4
Pointert n stringje
Pointert mund t shfrytzohen edhe gjat puns me stringje, duke i deklaruar ato t tipit char. Shembull Programi pointS1, prmes s cilit lexohet dhe shtypet fjalia me m s shumti n=20 karaktere. N program sht deklaruar pointeri a, i cili shfrytzohet gjat shtypjes s antarve t vektorit x, ku ruhet fjalia e lexuar.
// Programi pointS1 #include <iostream> #include <iomanip> using namespace std; int main() { const int n=20; char x[n], *a; int i; cout << "\nTeksti q lexohet: "; cin.getline(x,n); cout << "\nTeksti i lexuar\n\n"; a=&x[0];
Pointert 265
for (i=0;x[i]!='\0';i++) cout << setw(4+i) << *(a+i) << endl; cout << "\n"; return 0; }
Te programi i dhn, fillimisht pointeri a sht deklaruar i tipit char, meq adresa q ruhet n t i prket nj variable t ktij tipi. Pastaj, adresa e antarit t par t vektorit x prcillet te pointeri me shprehjen:
a=&x[0];
Teksti i lexuar prmes komands:

cin.getline(x,n);
shtypet duke e shfrytzuar pointerin e forms *(a+i), kurse numri i simboleve n vektorin x, tek unaza for, e cila shfrytzohet pr shtypje, lidhet me kushtin x[i]!='\0' . Rezultati q shtypet n ekran do t duket si n Fig.5.30.
Fig.5.30 Pamja e ekranit pas ekzekutimit t programit pointS1
Fusha pointersh
Pr t vendosur stringje brenda fushave, p.sh., si jan emrat e ndryshm, fushat duhet t deklarohen si dydimensionale, prkatsisht si matrica. Por, nse
266 Programimi i orientuar n objekte fushat e tilla ruhen n nj vektor t deklaruar si fush pointersh (ang. array of pointers), hapsira memoruese do t jet minimale. Shembull Programi pointS2, prmes s cilit emrat e stinve t vitit ruhen n matricn stina dhe njkohsisht t njjtat shtypen n ekran.
// Programi pointS2 #include <iostream> #include <iomanip> using namespace std; int main() { const int m=4,n=9; int i,j; char stina[m][n]={"Pranvera", "Vera", "Vjeshta", "Dimri"}; cout << "\nStint e vitit\n\n"; for (i=0;i<m;i++) { cout << " "; for (j=0;j<n;j++) cout << stina[i][j]; cout << "\n"; } cout << endl; return 0; }
Nse ekzekutohet programi, rezultati n ekran do t duket ashtu si sht dhn n Fig.5.31.

pointS2
N program, edhe prkundr asaj se emrat e stinve kan gjatsi t ndryshme, pr secilin prej tyre n matricn stina jan rezervuar n=9 vende, aq
Pointert 267 sa nevojiten pr vendosjen e emrit m t gjat (Pranvera), prfshir simbolin e fundit '\0'. Humbja e hapsirs memoruese, duke shfrytzuar matrica, ashtu si u dha n shembullin paraprak, mund t eliminohet nse emrat e stinve t vitit ruhen n vektor t deklaruar si fusha pointersh.
Shembull
Versioni pointS3 i programit pointS2, tek i cili, pr ruajtje t emrave t stinve t vitit, shfrytzohet vektori stina i deklaruar si pointer.
// Programi pointS3 #include <iostream> using namespace std; int main() { const int m=4; int i,j; char *stina[m]={"Pranvera", "Vera", "Vjeshta", "Dimri"}; cout << "\nStint e vitit\n\n"; for (i=0;i<m;i++) { cout << " "; for (j=0; *(stina[i]+j)!='\0' ;j++) cout << *(stina[i]+j) ; cout << "\n"; } cout << endl; return 0; }
Me deklarimin e fushs stina si pointer, n fakt formohet nj vektor pointersh, n antart e t cilit ruhen adresat ku fillojn vendosjet e emrave t stinve t veanta. Rezultati i programit t dhn do t duket i njjt me at q u dha n Fig.5.31.
Pointert si parametra t funksioneve

Rndsi t veant ka prdorimi i pointerve si parametra funksionesh, sepse prmes tyre mundsohet prcjellja direkte e vlerave prej programit kryesor n funksione dhe e rezultateve t llogaritjeve t ndryshme - prej funksioneve te programi kryesor.
Mundsit themelore
N vijim, prmes shembujve do t jepen disa versione t prcjelljes s vlerave n nnprograme dhe marrjes s rezultateve nga nnprogramet, duke i shfrytzuar pointert. Shembull Programi pointF1a, prmes s cilit llogaritet vlera e funksionit:
y = x + 3
duke e shfrytzuar edhe funksionin dita me parametrin formal

x t tipit pointer.
// Programi pointF1a #include <iostream> using namespace std; double dita(int *x); int main() { int x; double y; cout << "\nVlera e lexuar x: "; cin >> x; y=dita(&x); cout << "\nVlera e llogaritur y=" << y << "\n\n"; return 0; } double dita(int *x) { double y;
Pointert 269
y=*x+3; return y; }
Ktu, meq parametri formal i funksionit sht deklaruar si pointer *x, gjat shfrytzimit t tij n programin kryesor pr llogaritjen e vlers s funksionit:
y=dita(&x);
si parametr aktual &x sht marr adresa e variabls x. Pas ekzekutimit t programit t dhn, rezultati n ekran do t duket ashtu si sht dhn n Fig.5.32. Fig.5.32 Pamja e ekranit pas ekzekutimit t programit
pointF1a
Pr parametrat formal te nnprogrami mund t mos shfrytzohen identifikator t njjt me ato t parametrave aktual prkats. Shembull Versioni pointF1b i programit pointF1a, tek i cili dallohet variabla e parametrit formal dhe ajo e parametrit aktual.
// Programi pointF1b #include <iostream> using namespace std; double dita(int *a); int main() { int x; double y; cout << "\nVlera e lexuar x: "; cin >> x; y=dita(&x); cout << "\nVlera e llogaritur y=" << y << "\n\n"; return 0; }
double dita(int *a) { double g; g=*a+3; return g; }
N nnprogram, si parametr formal sht shfrytzuar pointeri a. Kurse gjat thirrjes s tij n programin kryesor, parametri formal n fjal sht zvendsuar me adresn e variabls x. Njkohsisht, n nnprogram definohet llogaritja e vlers s funksionit g, i cili sht shnuar edhe te komanda return. Rezultati n ekran, pr vlern hyrse t njjt do t duket si ai q shihet n Fig.5.32. Rezultati q fitohet prmes llogaritjes n nnprogram mund edhe t shtypet, pa e prcjell at n programin kryesor. Shembull Versioni pointF1c i programit pointF1a, te i cili rezultati i llogaritjes shtypet n nnprogram.
// Programi pointF1c #include <iostream> using namespace std; void dita(int *x); int main() { int x; cout << "\nVlera e lexuar x: "; cin >> x; dita(&x); return 0; } void dita(int *x) { double y; y=*x+3; cout << "\nVlera e llogaritur y=" << y
Pointert 271
<< "\n\n"; return; }
Ktu, meq vlera e llogaritur shtypet n nnprogram, variabla y nuk sht shnuar n vazhdim t komands return dhe para emrit t funksionit sht shnuar fjala void.
Shembull
Versioni pointF2a i programit pointF1a, tek i cili rezultati i llogaritjes prcillet n programin kryesor duke e shnuar variabln prkatse si pointer t dyt.
// Programi pointF2a #include <iostream> using namespace std; void dita(int *a,double *g); int main() { int x; double y; cout << "\nVlera e lexuar x: "; cin >> x; dita(&x,&y); cout << "\nVlera e llogaritur y=" << y << "\n\n"; return 0; } void dita(int *a,double *g) { *g=*a+3; return; }
Brenda kllapave t funksionit ktu jan shfrytzuar si parametra formal pointert a dhe g. Gjat shfrytzimit t funksionit n programin kryesor:

dita(&x,&y);
prmes adress prkatse &y, vlera e llogaritur e variabls g, prej nnprogramit prcillet direkt te variabla y e funksionit. Nse ekzekutohet programi i dhn, rezultati do t duket si ai q sht dhn n Fig.5.32. Nuk ka asnj arsye q t mos shfrytzohen identifikator t njjt pr parametrat formal dhe parametrat aktual prkats.
Shembull
Versioni pointF2b i programit pointF2a, tek i cili emrat e parametrave formal dhe atyre aktual nuk dallohen mes vete.
// Programi pointF2b #include <iostream> using namespace std; void dita(int *x,double *y); int main() { int x; double y; cout << "\nVlera e lexuar x: "; cin >> x; dita(&x,&y); cout << "\nVlera e llogaritur y=" << y << "\n\n"; return 0; } void dita(int *x,double *y) { *y=*x+3; return; }
N vijim, sa her q nuk sht e nevojshme, parametrat formal dhe ata aktual do t quhen njlloj.
Pointert 273 Nuk sht e thn q t gjith parametrat e funksioneve t merren patjetr pointer. Shembull Programi pointF3, i cili shfrytzohet pr llogaritjen e vlers s funksionit y, i prcaktuar me shprehjen e dhn m par. Por, ktu vlera e variabls hyrse x n nnprogram sht marr si variabl e zakonshme.
// Programi pointF3 #include <iostream> using namespace std; void dita(int x,double *y); int main() { int x; double y; cout << "\nVlera e lexuar x: "; cin >> x; dita(x,&y); cout << "\nVlera e llogaritur y=" << y << "\n\n"; return 0; } void dita(int x,double *y) { *y=x+3; return; }
N program, variabla y, tek e cila ruhet vlera dalse nga nnprogrami, sht marr si pointer, sepse vetm n kt mnyr prcillet te programi kryesor pa e shnuar n vazhdim t komands return.
Mundsi t tjera
Nnprogramet mund t shfrytzohen pr llogaritje t vlerave t disa funksioneve, ose edhe procedurat llogaritse mund t jen m komplekse. Shembull Programi pointF4, prmes s cilit llogariten vlerat e funksioneve:
y = x + 3 z = 4* x 1
N program, pr definimin e funksioneve y dhe z shfrytzohet funksioni jeta, me parametra formal t tipit pointer.
// Programi pointF4 #include <iostream> using namespace std; void jeta(int *x,double *y,double *z); int main() { int x; double y,z; cout << "\nVlera e lexuar x: "; cin >> x; jeta(&x,&y,&z); cout << << << << << return 0; } "\nVlera e llogaritur y=" y "\n\nVlera e llogaritur z=" z "\n\n";
void jeta(int *x,double *y,double *z) { *y=*x+3; *z=4*(*x)-1; return; }
Ktu, si parametra formal t funksionit jeta jan marr pointert e variabls x dhe t rezultateve t funksioneve y e z.
Pointert 275
void jeta(int *x,double *y,double *z)
Gjat thirrjes s funksionit n fjal n programin kryesor:

jeta(&x,&y,&z);
si parametra aktual jan marr adresat e variablave prkatse hyrse (&x) dhe dalse (&y, &z). Rezultati, pas ekzekutimit t programit t dhn, pr vlern hyrse t variabls x do t duket si n Fig.5.33.

pointF4
Nnprogramet me pointer si parametra formal mund t shfrytzohen edhe pr llogaritje t vlerave pr funksione t fardoshme. Shembull Programi pointF5, prmes s cilit llogariten vlerat e funksionit:
n+1
y = 4x + 3
i=1
(2i + 1)
N program, pr definimin e funksionit y prdoret funksioni alfa, n t cilin si parametra formal shfrytzohen pointert e variablave x, n dhe y.
// Programi pointF5 #include <iostream> using namespace std; void alfa(double *x,int *n,double *y); int main() { int n;

double x,y; cout << "\nVariabla x: "; cin >> x; cout << "\nVariabla n: "; cin >> n; alfa(&x,&n,&y); cout << "\nVlera e llogaritur y=" << y << "\n\n"; return 0; } void alfa(double *x,int *n,double *y) { int i; double s=0; for (i=1;i<=*n+1;i++) s=s+(2*i+1); *y=4*(*x)+3*s; return; }
Ktu, si parametra formal paraqiten pointert e dy variablave hyrse x dhe n, si dhe pointeri i rezultatit y. Nse ekzekutohet programi i dhn, pr vlerat hyrse, t cilat kompjuterit i jepen prmes tastiers, rezultati do t duket ashtu si sht dhn n Fig.5.34. Fig.5.34 Pamja e ekranit pas ekzekutimit t programit
pointF4
N programin e dhn m sipr, nnprogrami mund t shfrytzohet vetm pr llogaritjen e shums, ose vlera e llogaritur e funksionit y mund t shtypet edhe brenda nnprogramit.
Vektort si pointer
Pr prcjellje t antarve t vektorve n nnprograme mund t shfrytzohen si pointer adresat e antarve t par t tyre, ose edhe vet vektort. Shembull Programi pointF6a, prmes s cilit nga antart e vektorit t
Pointert 277 dhn A(n) formohet vektori i ri B(n), duke e shfrytzuar funksionin vekt.
// Programi pointF6a #include <iostream> #include <iomanip> using namespace std; const int n=5; void vekt(int *a); int main() { int A[n]={5,18,7,12,9}, *a; a=&A[0]; vekt(a); return 0; } void vekt(int *a) { int i,B[n]; cout << "\n Antart e vektorve" << "\n\n A B" << "\n ----------------" << "\n"; for (i=0;i<n;i++) { B[i]=*(a+i)+3; cout << setw(8) << *(a+i) << setw(8) << B[i] << endl; } cout << "\n"; return; }
Si parametr formal i nnprogramit ktu paraqitet vetm pointeri a, tek i cili ruhet adresa e antarit t par t vektorit:
a=&A[0];
278 Programimi i orientuar n objekte Pastaj, prmes ksaj adrese n nnprogram llogariten adresat e antarve t tjer t vektorit, duke e shfrytzuar shprehjen *(a+i), gj q shihet edhe te shprehja pr llogaritjen e antarve t vektorit B:
B[i]=*(a+i)+3;
si edhe te komanda pr shtypje t antarve t vektorit A. Rezultati n ekran, pas ekzekutimit t programit t dhn, do t duket si n Fig.5.35.

pointF6a
Prcjellja e vlerave t antarve t vektorve n nnprogram mund t bhet edhe duke e deklaruar vektorin si pointer. Shembull Versioni PointF6b i programit pointF6a, tek i cili si parametr i funksionit vekt merret vektori A(n).
// Programi pointF6b #include <iostream> #include <iomanip> using namespace std; const int n=5; void vekt(int *A); int main() { int A[n]={5,18,7,12,9}; vekt(A); return 0; } void vekt(int *A) { int i,B[n]; cout << "\n Antart e vektorve"
Pointert 279
<< "\n\n A B" << "\n ----------------" << "\n"; for (i=0;i<n;i++) { B[i]=A[i]+3; cout << setw(8) << A[i] << setw(8) << B[i] << endl; } cout << "\n"; return; }
Ktu, vektori A paraqitet si parametr formal i nnprogramit vekt, duke e deklaruar at si pointer:
void vekt(int *A)
Kurse gjat shfrytzimit t funksionit, si parametr aktual i tij shfrytzohet vet vektori:
vekt(A);
N kt mnyr, brenda nnprogramit antart e veant t vektorit shfrytzohen direkt, duke i shnuar ato si A[i]. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si ai q sht dhn n Fig.5.35.
Pointert n funksione
Gjat ekzekutimit t programeve, funksionet q prfshihen brenda tyre vendosen n hapsira memoruese t caktuara. Adresa ku fillon vendosja e nj funksioni n memorien e kompjuterit quhet adres e funksionit (ang. function address). Pr ruajtje t ksaj adrese mund t shfrytzohet pointeri n funksion (ang. pointer to function), i cili njihet edhe si pointer funksioni (ang. function pointer). Pas shoqrimit t adress n fjal te pointeri i funksionit, ai mund t shfrytzohet pr thirrjen e funksionit n fjal. Shembull Programi pointF7a, prmes s cilit llogaritet vlera e funksionit:
y = 3x + 4
duke e shfrytzuar edhe funksionin jeta me parametrin formal

x t tipit double.
// Programi pointF7a #include <iostream> using namespace std;
void jeta(double x);

int main() { void (*a)(double x); a=jeta; double x; cout << "\nVlera e lexuar x: "; cin >> x;
(*a)(x);
return 0; } void jeta(double x) { double y; y=3*x+4; cout << "\nVlera e llogaritur y=" << y << "\n\n"; return; }
N program sht definuar funksioni jeta, prmes s cilit llogaritet dhe shtypet vlera e funksionit y. Me qllim t thirrjes s funksionit prmes pointerit a, n pjesn e programit kryesor, prmes shprehjes:
void (*a)(double x);
sht deklaruar pointeri n fjal, duke e shnuar brenda kllapave, por i shoqruar edhe me pjesn e parametrave t funksionit. Pointerit i shoqrohet adresa e funksionit jeta, duke e shfrytzuar shprehjen:
a=jeta;
Pas ksaj, funksioni jeta thirret prmes pointerit a, gjat s cils i shoqrohet edhe parametri aktual x, n kt mnyr:
Pointert 281
(*a)(x);
Nse ekzekutohet programi i dhn, pr vlern hyrse x, e cila kompjuterit i jepet prmes tastiers, rezultati do t duket si n Fig.5.36. Fig.5.36 Pamja e ekranit pas ekzekutimit t programit
pointF7a
Prve funksioneve, njkohsisht edhe parametrat e tyre mund t merren si pointer.
Shembull
Versioni PointF7b i programit pointF7a, tek i cili parametri x merret si pointer.
// Programi pointF7b #include <iostream> using namespace std; void jeta(double *x); int main() { void (*a)(double *x); a=jeta; double x; cout << "\nVlera e lexuar x: "; cin >> x;
(*a)(&x);
return 0; } void jeta(double *x) { double y; y=3*(*x)+4; cout << "\nVlera e llogaritur y="

<< y << "\n\n"; return; }
Ky version i programit dallohet nga versioni pointF7a vetm n parametrin x t funksionit, i cili gjat definimit t tij shnohet si *x, kurse gjat thirrjes - si &x. Pas ekzekutimit t programit, rezultati n ekran do t duket si ai q sht dhn n Fig.5.36. Rezultati i funksionit mund t prcillet edhe te programi kryesor, duke e shnuar n vazhdim t komands return. Shembull Versioni PointF7c i programit pointF7a, tek i cili rezultati i llogaritjes brenda funksionit jeta shfrytzohet te programi kryesor.
// Programi pointF7c #include <iostream> using namespace std;
double jeta(double x);

int main() { double (*a)(double x); a=jeta; double x,y; cout << "\nVlera e lexuar x: "; cin >> x;
y=(*a)(x);
cout << "\nVlera e llogaritur y=" << y << "\n\n"; return 0; }
double jeta(double x) { double y; y=3*x+4; return y; }
Pointert 283 Ktu, funksioni jeta sht deklaruar i tipit double, sepse prej tij merret rezultati i funksionit y, duke e shnuar variabln prkatse n vazhdim t komands return. Gjithashtu, funksioni thirret prmes shprehjes:
y=(*a)(x);
Rezultati i llogaritjes, pr vlern hyrse t variabls x si ajo q u zgjodh te versionet paraprake t programit, n ekran do t duket ashtu si sht dhn n Fig.5.36.
Fusha pointersh n funksione

Pointert n funksione mund t formojn fusha pointersh t funksioneve. N kt mnyr lehtsohet thirrja e funksioneve, duke e prcaktuar indeksin e funksionit q thirret.
Shembull
Programi PointF8a, prmes s cilit tregohet shfrytzimi i fushs s pointerve n funksione, duke e formuar fushn a t 3 pointerve n funksionet jeta, dita dhe nata.
// Programi pointF8a #include <iostream> using namespace std; void jeta(double x); void dita(double x); void nata(double x); int main() { int i; void (*a[3])(double)={jeta,dita,nata}; for (i=0;i<=2;i++) (*a[i])(5.6); cout << "\n"; return 0; } void jeta(double x) { cout << "\nThirrja e funksionit jeta" << "\nVlera e llogaritur y=" << 2*x+1

<< "\n"; return; } void dita(double x) { cout << "\nThirrja e funksionit dita" << "\nVlera e llogaritur z=" << x+2 << "\n"; return; } void nata(double x) { cout << "\nThirrja e funksionit nata" << "\nVlera e llogaritur v=" << 4*x+3 << "\n"; return; }
N program, fusha e pointerve n 3 funksione sht deklaruar:

void (*a[3])(double)={jeta,dita,nata};
ku, si shihet, emrat e funksioneve jeta, dita dhe nata, t cilve u prkasin pointert a[1], a[2] dhe a[3], jan prfshir brenda kllapave. Ktu sht parapar q t thirren t 3 funksionet prmes pointerve n fjal, duke e shnuar brenda unazs for komandn pr thirrje:
(*a[i])(5.6);
ku vlera 5.6 i prket variabls x, e cila shfrytzohet nga funksionet e veanta. Nse ekzekutohet programi i dhn, rezultati do t duket si n Fig.5.37.

pointF8a
Pointert 285 Prej ktu shihet se rezultatet n ekran shtypen prmes ekzekutimit t 3 funksioneve t veanta, me radhn e zgjedhur gjat deklarimit t fushs s pointerve n funksione. Funksionet do t ekzekutohen edhe nse brenda unazs for pointert shkruhen n formn:
a[i](5.6);
pa i shfrytzuar kllapat dhe operatorin *. Nnkuptohet se funksionet, pointert e t cilve jan prfshir n fush, mund t thirren edhe sipas dshirs, duke e prcaktuar vlern e indeksit prkats. Shembull Programi kryesor i versionit PointF8b t programit PointF8a, prmes s cilit tregohet ekzekutimi i njrit nga 3 funksionet, pointert e t cilve prfshihen n nj fush t pointerve, duke e zgjedhur indeksin prkats.
// Programi pointF8b #include <iostream> using namespace std; void jeta(double x); void dita(double x); void nata(double x); int main() { int i;
void (*a[3])(double)={jeta,dita,nata}; Leximi: cout << "\nZgjidh 0, 1 ose 2 pr i: "; cin >> i;
if (i>=0 && i<=2) (*a[i])(5.6); else goto Leximi; cout << "\n"; return 0; }
Ktu nuk sht dhn pjesa e nnprogrameve, meq ato mbesin t njjta si te versioni i programit pointF8a. N program, prmes komands pr lexim cin, lexohet indeksi i i 3 vlerave t mundshme t indekseve t pointerve. Nse prmes tastiers kompjuterit i jepet ndonj vler jasht kufijve t vlerave t lejueshme, ekzekutohet komanda:
goto Leximi;
pr kthim pas me qllim t prsritjes s leximit t vlers s variabls i. Kshtu, p.sh., nse pr variabln i prmes tastiers kompjuterit i jepet vlera 1, n ekran do t shtypet rezultati q fitohet pas ekzekutimit t funksionit dita, ashtu si shihet n Fig.5.38.

pointF8b
Pointert n struktura
Pointert, prve te t dhnat e tipeve t zakonshm, p.sh., si jan int, double, char etj., mund t shfrytzohen edhe gjat operimit me struktura. N kt rast, deklarimi i variablave t tipit pointer pr strukturat dhe operimi me antart e tyre nuk dallon aspak nga mnyra e shfrytzimit t pointerve te tipet e zakonshm t t dhnave. Shembull Versione t programit structP1, n t cilt definohet struktura brinjet dhe pastaj inicializohen me vlera variablat a dhe b, t prfshira n struktur, n rrug direkte dhe me ndrmjetsimin e pointerit.
a. Pa pointer
// Programi structP1a #include <iostream> using namespace std;
Pointert 287
int main() { brinjet kater; kater.a=8; kater.b=5; cout << << << cout << << << return 0; } "\nVlerat e variablave t strukturs" "\n\nVlera e brinjs a: " kater.a; "\nVlera e brinjs b: " kater.b "\n\n";
N program, fillimisht, sht definuar struktura brinjet n t ciln prfshihen variablat a e b, dhe sht deklaruar variabla e strukturs kater. Pastaj, pasi variablat n fjal inicializohen direkt me vlerat 8 dhe 5, prmes komandave prkatse urdhrohet edhe shtypja e vlerave t tyre. Rezultati n ekran duket si n Fig.5.39.
Fig.5.39 Pamja e ekranit pas ekzekutimit t programit structP1a b. Me pointer

// Programi structP1b #include <iostream> using namespace std; struct brinjet { double a,b; }; int main() { brinjet D; brinjet *kater; kater=&D;

(*kater).a=8; (*kater).b=5;
cout << << << cout << << << return 0; } "\nVlerat e variablave t strukturs" "\n\nVlera e brinjs a: " (*kater).a; "\nVlera e brinjs b: " (*kater).b "\n\n";
N kt version t programit, para se t inicializohen variablat, n rrug t zakonshme deklarohet pointeri:

brinjet *kater;
Pastaj, pr ta shfrytzuar pointerin gjat inicializimit dhe shtypjes s vlerave t variablave, adresa e variabls s objektit D prcillet te pointeri:
kater=&D;
Gjat inicializimit t variablave me vlera prdoren shprehjet:

Ktu, shfrytzimi i kllapave sht i domosdoshm, sepse pika (.) ka prparsi m t madhe se operatori *. Nse pointeri shfrytzohet pa i prdorur kllapat, interpretimi i shprehjeve do t jet i gabueshm. Gjat shtypjes s vlerave t variablave t prfshira n struktur, n komandat pr shtypje, ato prsri shkruhen n formn:
(*kater).a (*kater).b
Nse ekzekutohet ky version i programit, rezultati do t jet i njjt me at q shihet n Fig.5.39. Me qllim t thjeshtimit t qasjes te komponentet e strukturs, n gjuhn
C++ mund t shfrytzohet operatori shigjet -> pr qasje tek antart , i cili realizohet prmes simboleve minus (-) dhe m i madh (>).
Shembull
Versioni structP1c i programit structP1b, n t cilin pr qasje te komponentet e strukturs shfrytzohet operatori ->.
Pointert 289
// Programi structP1c #include <iostream> using namespace std; struct brinjet { double a,b; }; int main() { brinjet D; brinjet *kater; kater=&D; kater->a=8; kater->b=5; cout << << << cout << << << return 0; } "\nVlerat e variablave t strukturs" "\n\nVlera e brinjs a: " kater->a; "\nVlera e brinjs b: " kater->b "\n\n";
Brenda programit njkohsisht mund t shfrytzohen operatort * dhe

-> pa ndonj kufizim.
Pointert n objekte
Plotsisht njlloj sikurse te strukturat, pointert mund t shfrytzohen edhe gjat operimit me objekte dhe me antart e prfshir n klasat prkatse.
Qasja te variablat e klass

Shfrytzimi i pointerve n objekte, gjat qasjes te variablat q prfshihen n klasat prkatse, nuk dallon nga shfrytzimi i pointerve pr qasje te variablat q prfshihen n komponentet e strukturave. Shembull Versione t programit classP1, n t cilt definohet klasa brinjet, n komponentet e s cils prfshihen variablat a dhe b, si dhe objekti prkats D.
290 Programimi i orientuar n objekte a. Pa pointer

// Programi classP1a #include <iostream> using namespace std; struct brinjet { public: double a,b; }; int main() { brinjet D; D.a=8; D.b=5; cout << << << cout << << << return 0; } "\nVlerat e variablave t klass" "\n\nVlera e brinjs a: " D.a; "\nVlera e brinjs b: " D.b "\n\n";
Pr qasje te variablat e prfshira n komponentet e klass ktu shfrytzohet objekti D dhe pika, p.sh., duke i shfrytzuar shprehjet:
D.a=8; D.b=5;
Rezultati q fitohet pas ekzekutimit t programit n ekran do t duket ashtu si sht dhn n Fig.5.40. Fig.5.40 Pamja e ekranit pas ekzekutimit t programit classP1a b. Me pointer
// Programi classP1b #include <iostream> using namespace std;
Pointert 291
struct brinjet { public: double a,b; };

int main() { brinjet D; brinjet *kater; kater=&D; (*kater).a=8; (*kater).b=5; cout << << << cout << << << return 0; } "\nVlerat e variablave t klass" "\n\nVlera e brinjs a: " (*kater).a; "\nVlera e brinjs b: " (*kater).b "\n\n";
Ktu, pr qasje te variablat e prfshira n komponentet e klass prdoret pointeri i cili tregon tek objekti D. Deklarimi i pointerit dhe shfrytzimi i tij gjat inicializimit t variablave a dhe b me vlera, si dhe gjat shtypjes s vlerave t tyre, nuk dallon aspak nga ajo q u dha te pjesa mbi pointert n variablat e strukturave. Kshtu, p.sh., gjat inicializimit t variablave, shprehjet q shfrytzohen shkruhen n kt mnyr:
Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si ai q shihet n Fig.5.39. Edhe gjat operimit me antart e klass mund t shfrytzohet operatori shigjet ->, plotsisht njlloj si edhe te strukturat. Kshtu, dy shprehjet pr inicializim t variablave do t shkruhen:
kater->a=8; kater->b=5;
Qasja te funksionet e klasave

Pr thirrje t funksioneve q prfshihen brenda komponenteve t klasave, shfrytzimi i pointerve n objektet prkatse nuk dallon nga shfrytzimi i tyre pr qasje te funksionet n komponentet e klasave. Shembull Versione t programit classP2, n t cilt definohet klasa Jeta, q i prmban variablat m e a, si dhe funksionet vlera dhe shtypja.
a. Pa pointer
// Programi classP2a #include <iostream> using namespace std; class Jeta { private: int m; public: double a; void vlera(int k) { m=k; } void shtypja() { cout << "\nVlera e variabls private m=" << m << "\n"; } }; int main() { Jeta Dita;
Dita.vlera(77); cout << "\nLeximi i vlers s variabls a: "; cin >> Dita.a; Dita.shtypja(); cout << "\nVlera e variabls publike a="
Pointert 293
<< Dita.a << "\n\n"; return 0; }
Si shihet n program, pr qasje te funksionet q prfshihen n komponentet e klass, para funksioneve shkruhet objekti Dita:
Dita.vlera(77); Dita.shtypja();
gj q sht njlloj si edhe gjat qasjes te variabla a, kur shfrytzohet shprehja Dita.a. Pas ekzekutimit t programit t dhn, rezultati n ekran do t duket si n Fig.5.41.
Fig.5.41 Pamja e ekranit pas ekzekutimit t programit classP2a b. Me pointer

// Programi classP2b #include <iostream> using namespace std; class Jeta { private: int m; public: double a; void vlera(int k) { m=k; } void shtypja() { cout << "\nVlera e variabls private m=" << m << "\n"; } };
int main() { Jeta Dita; Jeta *p; p=&Dita;
(*p).vlera(77);
cout << "\nLeximi i vlers s variabls a: "; cin >> (*p).a;
(*p).shtypja(); cout << "\nVlera e variabls publike a=" << (*p).a << "\n\n"; return 0; }
Ktu, gjat thirrjes s funksioneve, pointeri p, i cili tregon te objekti Dita, shkruhet brenda kllapave, para funksioneve q thirren, n kt mnyr:
(*p).vlera(77); (*p).shtypja();
Kjo form e shfrytzimit t pointerit nuk dallon aspak nga ajo q prdoret pr qasje te variabla n komponenten publike t klass:
(*p).a
Pas ekzekutimit t ktij versioni t programit, rezultati do t duket njlloj me at q sht dhn n Fig.5.42. Edhe gjat thirrjes s funksioneve mund t shfrytzohet operatori ->. Shembull Versioni classP2c i programit classP2b, n t cilin pr qasje te variablat dhe te funksionet q prfshihen n komponentet publike t klass shfrytzohet operatori ->.
N vijim sht dhn vetm pjesa e programit kryesor t versionit

classP2c, sepse pjesa tjetr e tij nuk dallon aspak nga versioni i programit classP2b, i cili u dha m sipr.
int main() { Jeta Dita;
Pointert 295
Jeta *p; p=&Dita;
p->vlera(77);
cout << "\nLeximi i vlers s variabls a: "; cin >> p->a;
p->shtypja(); cout << "\nVlera e variabls publike a=" << p->a << "\n\n"; return 0; }
Shfrytzimi i pointerit n objekte gjat qasjes te komponentet publike t klasave nuk dallon aspak, nse funksionet q prfshihen n klasa definohen jasht strukturs s tyre.
5
Referencat
Referencat e zakonshme Parametrat formal referent Fushat referente Parametrat referent brenda strukturave Parametrat referent brenda klasave Objektet referente 296 302 306 309 311 312
N gjuhn C++, prmes referencave mund t deklarohen dy ose m shum variabla ose objekte, te t cilat ruhen t dhna t njjta, si dhe prcillen ndryshimet q ndodhin n seciln prej tyre. Pr deklarimin e referencave shfrytzohet operatori pr referim &, i cili nuk dallohet nga simboli q shfrytzohet pr marrjen e adresave te pointert. Referencat kryesisht shfrytzohen gjat operimit me parametrat e funksioneve, gj q sht shpjeguar m par edhe n kapitullin ku flitet mbi klasat.
Referencat e zakonshme
Brenda programeve mund t shfrytzohen variabla referente t zakonshme, pr t cilat thuhet se jan me referenc t pavarur (ang. independent reference). Para se t deklarohet nj variabl referente, duhet t jet deklaruar variabla s cils ajo i referohet. Variabla referente deklarohet:
t &r=v;
ku jan:
r - variabla referente. t - tipi i variabls referente. v - variabla s cils i referohet variabla referente.
Pas ktij deklarimi, kompjuteri variabln r e llogarit si sinonim (ang. synonym, alias) t variabls v. Me kt nnkuptohet se do ndryshim q ndodh te variabla v do t prcillet edhe te variabla r dhe anasjelltas. Si u theksua edhe m sipr, deklarimi i variabls referente r lejohet nga kompjuteri pasi paraprakisht t jet deklaruar variabla v t cils ajo i referohet. Shembull Programi ref1, prmes s cilit tregohet deklarimi i variabls z, si referente t variabls d.
Referencat 297
// Programi ref1 #include <iostream> using namespace std; int main() { int d; d=793; cout << "\nVlera e variabls d: " << d << "\n"; int &z=d; cout << "\nVlera e variabls z: " << z << "\n\n"; return 0; }
N program, fillimisht, sht deklaruar variabla d e tipit int, dhe pasi i shoqrohet vlera 793 ajo edhe shtypet. Pastaj, prmes komands:
int &z=d;
variabla z deklarohet si variabl referente. Pas ksaj, variabla n fjal inicializohet automatikisht me vlern e variabls d, meq bhet sinonim i saj. Nse ekzekutohet programi i dhn, rezultati q shtypet n ekran do t duket si n Fig.5.1. Fig.5.1 Pamja e ekranit pas ekzekutimit t programit
ref1
Variabls referente mund t'i shoqrohen vlera edhe n rrug direkte, ngjashm si u shoqrohen vlera variablave t zakonshme. Si rezultat, ndryshimi i vlers q ruhet te variabla referente prcillet edhe te variabla s cils ajo i referohet. Shembull Versioni ref2 i programit ref1, prmes s cilit tregohet ndikimi i ndryshimit t vlers s variabls referente z edhe te variabla d.

// Programi ref2 #include <iostream> using namespace std; int main() { int d; d=793; cout << "\nVlera e variabls d: " << d << "\n"; int &z=d; cout << "\nVlera e variabls z: " << z << "\n\n"; z=249; cout << << << << << return 0; } "\nVlera e re e variabls z: " z "\n\nVlera e re e variabls d: " d "\n\n";
N pjesn e fundit t programit, variabls referente z i sht shoqruar vlera 249. Si rezultat, ndryshimi i vlers te variabla n fjal prcillet edhe te variabla d, s cils ajo i referohet, gj q shihet edhe nga rezultati q shtypet n ekran (shih Fig.5.2).
Fig.5.2 Pamja e ekranit pas ekzekutimit t programit ref2 Disa variabla referente njkohsisht mund t'i refereohen nj variable t zakonshme.
Referencat 299 Shembull Versioni ref3 i programit ref1, prmes s cilit tregohet deklarimi i dy variablave referente z e v, t cilat i referohen variabls d.
// Programi ref3 #include <iostream> using namespace std; int main() { int d; d=793; cout << "\nPas referencs s par" << "\n\nVariabla d: " << d; int &z=d; cout << "\nVariabla z: " << z << "\n\n"; int &v=d; cout << << << << << << << << return 0; } "Pas referencs s dyt" "\n\nVariabla d: " d "\nVariabla z: " z "\nVariabla v: " v "\n\n";
Ktu, si variabla referente jan deklaruar variablat z dhe v, t cilat njkohsisht i refereohen variabls d. Pas ksaj, te t tri variablat ruhet vlera 793, e cila i sht shoqruar variabls d n fillim t programit, gj q shihet edhe nga rezultati q shtypet n ekran (shih Fig.5.3), pas ekzekutimit t programit t dhn.

ref3
N programin e dhn, pavarsisht se cila nga vlerat e 3 variablave ndryshohet, vlerat e tyre gjithnj do t jen t barabarta. Brenda nj programi, referimi i deklaruar ndaj nj variable nuk mund t ndryshohet m.
Konstantet referente
Nse para variabls referente shnohet fjala const, do t deklarohet nj konstante referente. N form t prgjithshme deklarimi i konstantes referente duket:
const t &r=v;
ku jan:
r - konstanta referente. t - tipi i konstantes referente. v - vlera e cila i shoqrohet konstantes referente.
Pas ktij deklarimi, konstantes referente r i shoqrohet vlera v. Shembull Programi ref4a, prmes s cilit tregohet deklarimi i konstantes referente z, s cils i shoqrohet vlera 538.
// Programi ref4a #include <iostream> using namespace std; int main() { const int &z=538; cout << "\nVlera e konstantes z: "
Referencat 301
<< z << "\n\n"; return 0; }
Pasi t deklarohet konstantja referente z dhe t'i shoqrohet vlera 538, ndryshimi i saj nuk do t lejohet nga kompjuteri, nse p.sh., n vijim t programit shkruhet shprehja:
z=649;
Shprehjet pr deklarimin e konstanteve referente nuk mund t shkruhen pa fjaln const n rastet kur atyre u shoqrohet ndonj vler konstante. P.sh., komanda pr deklarimin e variabls referente z te programi i dhn m sipr nuk mund t shkruhet n formn:
int &z=538;
Konstanteve referente mund t'u shoqrohen edhe vlera t variablave. Shembull Versioni ref4b i programit ref4a, prmes s cilit tregohet shoqrimi i vlers s variabls x gjat deklarimit t konstantes referente z.
// Programi ref4b #include <iostream> using namespace std; int main() { int x=137; const int &z=x; cout << "\nVlera e konstantes z: " << z << "\n\n"; return 0; }
Edhe n kt rast, vlera e shoqruar nuk mund t ndryshohet prmes ndonj shoqrimi tjetr.
Parametrat formal referent

Nse pas tipit t parametrit formal t nj funksioni shnohet simboli &, variabla prkatse paraqet nj paremetr formal referent. Pastaj, kur thirret funksioni duke e shnuar si parametr aktual nj variabl t zakonshme n vend t parametrit formal referent, adresa e parametrit aktual i shoqrohet parimetrit formal referent. N kt mnyr, gjat ekzekutimit t programit, parametri formal referent e shfrytzon vlern q sht vendosur n adresn e parametrit aktual prkats. Shembull Programi funkPa, prmes s cilit tregohet llogaritja e siprfaqes s drejtkndshit me brinjt a dhe b, prmes funksionit Jeta, duke i shfrytzuar edhe parametrat formal referent.
a. Me parametra t zakonshm
// Programi funkPa #include <iostream> using namespace std; double Jeta(double x,double y); int main() { double a,b,s; cout << "\nBrinjt e drejtkndshit" << "\n\nBrinja a: "; cin >> a; cout << "\nBrinja b: "; cin >> b; s=Jeta(a,b); cout << "\nSiprfaqja e llogaritur s: " << s << "\n\n"; return 0; } double Jeta(double x,double y) { return x*y; }
Pas ekzekutimit t programit t dhn, pr vlerat e brinjve t drejtkndshit, t cilat kompjuterit i jepen prmes tastiers, rezultati n ekran do t duket si n Fig.5.4.
Referencat 303
Fig.5.4 Pamja e ekranit pas ekzekutimit t programit funkPa b. Me parametra formal referent
// Programi funkPb #include <iostream> using namespace std; double Jeta(double &x,double &y); int main() { double a,b,s; cout << "\nBrinjt e drejtkndshit" << "\n\nBrinja a: "; cin >> a; cout << "\nBrinja b: "; cin >> b; s=Jeta(a,b); cout << "\nSiprfaqja e llogaritur s: " << s << "\n\n"; return 0; } double Jeta(double &x,double &y) { return x*y; }
Te ky version i programit, parametat formal x dhe y t funksionit jeta jan marr si parametra formal referent. Kurse, gjat shfrytzimit t funksionit pr llogaritjen e vlers s siprfaqes s:
s=Jeta(a,b);
304 Programimi i orientuar n objekte parametart formal referent jan zvendsuar me variablat e zakonshme a dhe b. Nse ekzekutohet ky version i programit, pr vlera t njjta t brinjve t drejtkndshit, rezultati do t duket si ai q sht dhn n Fig.5.4. Si sht thn edhe m par, pr parametrat formal referent dhe pr parametrat aktual mund t shfrytzohen identifikator t njjt. Shembull Versioni funkPc i programit funkPb, tek i cili identifikatort e parametrave formal referent dhe i atyre aktual nuk dallojn mes vete.
// Programi funkPc #include <iostream> using namespace std; double Jeta(double &a,double &b); int main() { double a,b,s; cout << "\nBrinjt e drejtkndshit" << "\n\nBrinja a: "; cin >> a; cout << "\nBrinja b: "; cin >> b; s=Jeta(a,b); cout << "\nSiprfaqja e llogaritur s: " << s << "\n\n"; return 0; } double Jeta(double &a,double &b) { return a*b; }
N versionin e dhn t programit, gjat shfrytzimit t funksionit Jeta, parametrat formal referent a dhe b jan zvendsuar me parametra aktual, t cilt paraqesin identifikator t njjt.
Referencat 305
Parametrat referent si rezultate

Parametrat referent mund t shfrytzohen edhe pr marrjen e rezultateve, t cilat fitohen gjat llogaritjeve t ndryshme brenda funksioneve. Shembull Versioni funkPd i programit pr llogaritjen e siprfaqes s drejtkndshit me brinjt a dhe b, tek i cili edhe siprfaqja s, e cila llogaritet brenda funksionit jeta, deklarohet si parametr referent.
// Programi funkPd #include <iostream> using namespace std; void Jeta(double &a,double &b,double &s); int main() { double a,b,s; cout << "\nBrinjt e drejtkndshit" << "\n\nBrinja a: "; cin >> a; cout << "\nBrinja b: "; cin >> b; Jeta(a,b,s); cout << "\nSiprfaqja e llogaritur s: " << s << "\n\n"; return 0; } void Jeta(double &a,double &b,double &s) { s=a*b; }
Ktu, para emrit t nnprogramit sht shnuar fjala void, prkatsisht n fund t komands return te nnprogrami nuk sht shnuar rezultati s, sepse vlera e siprfaqes merret prmes parametrit aktual prkats gjat thirrjes s funksionit. Rezultati q fitohet n ekran pas ekzekutimit t programit do t duket ashtu si sht dhn m par n Fig.5.4, nse prmes tastiers kompjuterit i jepen vlera t njjta hyrse.
Fushat referente
Gjat operimit me antart e fushave, si referente mund t deklarohen edhe fushat. Si rezultat, vlerat e antarve t fushs referente barazohen me vlerat e antarve t nj fushe tjetr.
Vektort referent
N form t prgjithshme, deklarimi i vektorit referent duket:
t (&R)[n]=V;
ku jan:
R t n V
vektori referent. tipi i vektorit referent. numri i antarve t vektorit referent. vektori t cilit i referohet vektori referent.
Pas ktij deklarimi, vektorin R kompjuteri e llogarit si sinonim t vektorit V. Si rezultat, ndryshimet q ndodhin te vlerat e antarve t njrit vektor do prcillet edhe tek antart me indekse prkatse t vektorit tjetr. Shembull Programi refV, prmes s cilit tregohet deklarimi i vektorit B si vektor referent i vektorit A.
// Programi refV #include <iostream> #include <iomanip> using namespace std; int main() { const int n=5; int i; double A[n]={7,3,9,2,4}; cout << "\nVektori A\n\n"; for (i=0;i<n;i++) cout << setw(3) << A[i]; double (&B)[n]=A; cout << "\n\nVektori B\n\n"; for (i=0;i<n;i++)
Referencat 307
cout << setw(3) << B[i]; cout << "\n\n"; return 0; }
Rezultati q shtypet n ekran pas ekzekutimit t programit t dhn do t duket si n Fig.5.5.
Fig.5.5 Pamja e ekranit pas ekzekutimit t programit refV1 Nga rezultati i shtypur shihet se vlerat e antarve t vektorve A dhe B jan t barabarta. Kjo sht rezultat i barazimit t tyre gjat deklarimit t vektorit B si vektor referent i vektorit A. Por, vlerat e ndryshuara tek antart e veant t cilit do nga vektort automatikisht prcillen e dhe tek antart e vektorit tjetr. Kshtu, p.sh., nse pas deklarimit t vektorit referent te programi i msiprm shkruhen shprehjet:
A[2]=-5; B[4]=-8;
rezultati q shtypet n ekran do t duket si n Fig.5.6.
Fig.5.5 Pamja e ekranit pas ekzekutimit t programit refV1 pas ndryshimit t vlerave t dy antarve t vektorve
Matricat referente
Deklarimi i matrics referente n form t prgjithshme duket kshtu:
t (&R)[m][n]=M;
ku jan:
R - matrica referente. t - tipi i matrics referente. m, n - numri i rreshtave dhe i kolonave t matrics referente. M - matrica s cils i referohet matrica referente.
Pas ktij deklarimi, ndryshimet q ndodhin te vlerat e antarve t njrs matric do t prcillen edhe tek antart me indekse t njjta t matrics tjetr, meq kompjuteri i llogarit si matrica sinonime. Shembull Programi refM, prmes s cilit tregohet deklarimi i matrics B si matric referente t matrics A.
// Programi refM #include <iostream> #include <iomanip> using namespace std; int main() { const int m=4,n=5; int i,j; double A[m][n]={{-4,6,9,2,1}, {6,-3,8,5,9}, {-1,7,3,8,5}, {4,3,2,-7,2}}; cout << "\nMatrica A\n\n"; for (i=0;i<m;i++) { for (j=0;j<n;j++) cout << setw(5) << A[i][j]; cout << "\n"; } double (&B)[m][n]=A; cout << "\nMatrica B\n\n"; for (i=0;i<m;i++) { for (j=0;j<n;j++) cout << setw(5) << B[i][j]; cout << "\n";
Referencat 309
} cout << "\n"; return 0; }
Nse ekzekutohet programi i dhn, do t shtypen vlerat e antarve t dy matricave. Meq matricat jan rferente mes vete, anatrt e tyre do t ken vlera t njjta, ashtu si shihet n Fig.5.6.
Fig.5.6 Pamja e ekranit pas ekzekutimit t programit refM Edhe ktu mund t provohet se si ndryshimet e vlerave t antarve te njra matric automatikisht do t prcillen te matrica sinonime e saj.
Kufizime pr variablat referente

Nuk lejohet deklarimi m shum se nj her i variabls referente t njjt. Kshtu, p.sh., kompjuteri nuk i lejon njkohsisht deklarimet:
int &x=a; int &x=b;
sepse ktu tipi i variabls s njjt x deklarohet dy her. Nuk mund t deklarohet pointer n variabln referente, si dhe variabls referente nuk mund t'i referohemi.
Parametrat referent brenda strukturave

Parametrat e funksioneve q shfrytzohen brenda komponenteve t strukturave mund t merren si parametra referent. Kjo ka rndsi t veant kur prej strukturs merren rezultatet e llogaritjeve t ndryshme.
Shembull
Programi refS, n t cilin shfrytzohet struktura kater me variablat e brinjve a e b, si dhe e siprfaqes s dhe e perimetrit p t drejtkndshit n komponentet e saj. Pr t'i marr nga struktura vlerat e variablave s dhe p, shfrytzohet funksioni merri me parametrat referent x dhe y.
// Programi refS #include <iostream> using namespace std; struct kater { double a,b,s,p; void lexo(); void llogarit(); void merri(double &x,double &y); }; int main() { kater alfa; double s,p; alfa.lexo(); alfa.llogarit(); alfa.merri(s,p); cout << "\nVlerat e llogaritura" << "\n\nSiprfaqja s=" << s << "\nPerimetri p=" << p << "\n\n"; return 0; } void kater::lexo() { cout << "\nVlerat e lexuara" << "\n\nBrinja a: "; cin >> a; cout << "Brinja b: "; cin >> b; } void kater::llogarit() { s=a*b; p=2*(a+b);
Referencat 311
return; } void kater::merri(double &x,double &y) { x=s; y=p; }
Nse gjat ekzekutimit t programit, pr brinjt e drejtkndshit kompjuterit i jepen vlerat hyrse 5 dhe 4, rezultati n ekran do t duket ashtu si sht dhn n Fig.5.7.
Fig.5.7 Pamja e ekranit pas ekzekutimit t programit refS Shfrytzimi i parametrave referent veanrisht ka rndsi, nse duhet t merren t dhnat e prfshira n komponentet private t strukturave.
Parametrat referent brenda klasave

Ngjashm si te strukturat, edhe te klasat mund t shfrytzohen parametra referent si parametra t funksioneve brenda komponenteve t tyre, gj q sht shpjeguar edhe m par te kapitulli mbi klasat. Shembull Versioni refC i programit refS, n t cilin n vend t strukturs shfrytzohet klasa kater.
// Programi refC #include <iostream> using namespace std; class kater { private: double a,b,s,p; public: void lexo(); void llogarit();
void merri(double &x,double &y); }; .....................................
Ktu sht dhn vetm pjesa e par e programit, ku deklarohet klasa

kater. Kurse, pjesa tjetr e tij nuk dallon aspak nga programi refS, i cili u dha m sipr. N kt rast, vlerat q merren prmes funksionit merri prfshihen n
komponenten private t klass. Nse ekzekutohet programi i dhn, pr vlera hyrse t njjta rezultati do t duket ashtu si sht dhn n Fig.5.7.
Objektet referente
Objektet e strukturave dhe t klasave mund t deklarohen si objekte referente plotsisht njlloj, si deklarohen edhe variablat e zakonshme. Si rezultat, t dhnat q u shoqrohen variablave brenda komponenteve t strukturave dhe t klasave t objekteve referente do t barazohen me vlerat e variablave prkatse n objektet t cilave u referohen. Shembull Programi refO, prmes s cilit tregohet deklarimi i objektit referent nata i strukturs koha t cilit i referohet objekti dita i strukturs s njjt.
// Programi refO #include <iostream> using namespace std; struct koha { int a; float b; void shtypja(); }; int main() { koha dita; cout << "\nLeximi i vlerave" << "\n\n Variabla a: "; cin >> dita.a; cout << " Variabla b: "; cin >> dita.b; cout << "\nObjekti dita\n"; dita.shtypja(); koha &nata=dita; cout << "\nObjekti nata\n";
Referencat 313
nata.shtypja(); cout << endl; return 0; } void koha::shtypja() { cout << "\n Variabla a=" << a; cout << "\n Variabla b=" << b << "\n"; }
N programin e dhn, fillimisht, deklarohet objekti dita i strukturs

koha, n komponentet e s cils, prve variablave a dhe b, prfshihet edhe funksioni shtypja prmes s cilit shtypen vlerat prkatse t variablave n fjal. Pastaj, deklarohet objekti dita dhe prmes komandave prkatse lexohen vlerat
e variablave t tij. N fund, prmes komands:

koha &nata=dita;
deklarohet objekti referent nata, i cili i referohet objektit dita. N kt mnyr, objektet dita dhe nata bhen objekte sinonime, gj q rezulton n prcjelljen e vlerave te variablat brenda dy objekteve n fjal, sa her q ato ndryshohen te njri prej objekteve. Nse ekzekutohet programi i dhn, pr vlerat hyrse t cilat kompjuterit i jepen prmes tastiers, rezultati n ekran do t duket ashtu si sht dhn n Fig.5.8.
Fig.5.8 Pamja e ekranit pas ekzekutimit t programit refO
Plotsisht njlloj mund t deklarohen objekte referente edhe kur kemi t bjm me klasat.
6
Fajllat
Fajllat me qasje sekuenciale Qasja te fajllat n unaz Tekstet n fajlla Tekstet dhe numrat n fajlla Shkruarja dhe leximi i karaktereve Leximi i rreshtave Mode t hapjes s fajllave Pozita n fajll Fajllat me qasje direkte Objektet n fajlla Disa fajlla t hapur njkohsisht 317 328 341 343 347 352 356 360 372 391 404
Pr ruajtjen e prhershme t t dhnave t ndryshme n memorien periferike t kompjuterit, p.sh., si sht disku, shfrytzohen fajllat (ang. file). N prgjithsi, varsisht nga mnyra e qasjes n t dhnat q ruhen n fajlla, dallohen fajlla me qasje sekuenciale (ang. sequential-access files) dhe fajlla me qasje direkte (ang. random-access file). Po ashtu, duke e pasur parasysh mnyrn e ruajtjes s t dhnave n fajlla, fajllat mund t jen fajlla tekstual (ang. text file) dhe fajlla binar (ang. binary file). Kur flitet pr zhvendosjen e t dhnave, qoft gjat shtypjes n ekran, ose leximin e tyre duke ia dhn kompjuterit prmes tastiers, si dhe gjat shkruarjes n fajlla dhe leximit t tyre prej fajllave, shfrytzohen objekte q njihen si rrjedha (ang. stream). Prmes objekteve t tilla dhe funksioneve (metodave) brenda komponenteve t klasave t ndryshme mundsohet rrjedhja e t dhnave si vargje simbolesh. Meq t dhnat n fajlla paraqesin vargje bajtsh, adresa e bajtit n t cilin aktualisht shkruhet n fajll, ose e bajtit n t cilin lexohet prej fajllit, prcaktohet me pointerin e pozits n fajll. Vlera e ktij pointeri rritet automatikisht pr 1, kur n fajll lexohet ose shkruhet nj bajt. Pas bajtit t fundit q shkruhet n fajll vendoset markeri pr fund t fajllit (ang. end-of-file marker). Shfrytzimi i fajllave fillon me hapjen e tyre, gjat s cils emrave fizik t tyre u shoqrohen rrjedhat prkatse. Pr operim me t dhnat q shkruhen n fajlla dhe lexohen prej tyre, ose si thuhet - pr operim me rrjedhat e fajllave (ang. file stream), n gjuhn C++ shfrytzohen klasat pr hyrje/dalje (ang. Input/Output, I/O), t nxjerra nga klasa baz ios, organizimi hierarkik i t cilave shihet n Fig.7.1.
Fajllat 317
Fig.7.1 Klasat pr hyrje/dalje
Gjat puns me fajlla, n fillim t do programi patjetr vendosen komandat paraprocesorike me fajllat e ballins iostream dhe fstream.
Fajllat me qasje sekuenciale

Fajllat te t cilt t dhnat shkruhen ose lexohen si sekuenca (vargje) bajtsh, paraqesin fajlla me qasje sekuenciale (ang. sequential-access files). Te fajllat e till, si njsi elementare q mund t shkruhet n fajll, ose t lexohet nga fajlli sht bajti. N nj bajt mund t ruhet nj karakter, ku me karakter nnkuptohet nj shifr e numrave dhjetor (0, 1, ...9), nj shkronj (a, b, ...,z, A, B, ...,Z) ose nj simbol special (+, -, *, /, !, @, #, $, &, % etj.). Zakonisht, te fajllat me qasje sekuenciale t dhnat shkruhen si tekste, prandaj kta fajlla paraqesin fajlla tekstual (ang. text file). Pr do karakter q shkruhet n fajllat e till shfrytzohet nj bajt. Kshtu, p.sh., pr shkruarje n fajll t numrit 254781 shfrytzohen 6 bajt, aq sa ka shifra numri i dhn. Gjat shfrytzimit t t dhnave te fajllat me qasje sekuenciale, sht rnd t pozicionohemi direkt n nj t dhn t dshiruar. Gjithashtu, azhurimi i t dhnave n fajllat e till ka kufizime, meq gjat ndryshimit t t dhnave brenda tyre mund t shfrytzohet vetm numri ekzistues i bajtve. Kshtu, p.sh., nse n vend t numrit 3 shifror shkruhet nj numr 5 shifror, t dhnat n fajll do t dmtohen, sepse mbulohen 2 bajt t t dhns pas numrit 3 shifror. Pr azhurimin e numrit n fjal, n kt rast duhet t krijohet nj fajll i ri, n t cilin fillimisht do t prshkruhet komplet prmbajtja e fajllit para numrit q azhurohet, pastaj t insertohet numri 5 shifror dhe n fund t fajllit t prshkruhet edhe pjesa e mbetur e tij.
Shkruarja n fajll
T dhnat mund t shkruhen n fajll pasi paraprakisht t hapet fajlli, duke krijuar nj objekt, prkatsisht rrjedh t klass ofstream. Pr krijimin e objektit dhe hapjen e fajllit, komanda prkatse n formn e saj themelore shkruhet:
ofstream r("f",ios::out);
ku jan:
r - rrjedha e deklaruar si objekt i klasave pr pun me fajlla. f - emri i fajllit q hapet. ios::out - modi i hapjes s fajllit pr shkruarje.
Me emrin f t fajllit q hapet ktu nnkuptohet edhe folderi (direktoriumi), prkatsisht komplet shtegu n t cilin vendoset fajlli. Shembull Programi file1, prmes s cilit n fajllin Koha.txt regjistrohen vlerat 77 dhe 58.94 t variablave k dhe x.
// Programi file1 #include <iostream> #include <fstream> using namespace std; int main() { int k=77; double x=58.94; ofstream Shkruaj("D:/Libra/Koha.txt",ios::out); Shkruaj << k << ' ' << x; cout << "\nShkruarja n fajll prfundoi" << "\n\n"; return 0; }
N program, prmes komands:

ofstream Shkruaj("D:/Libra/Koha.txt",ios::out);
Fajllat 319 ktu krijohet rrjedha Shkruaj si objekt i klass ofstream, prmes s cils hapet fajlli Koha.txt, n folderin Libra t diskut D:, gj q prcaktohet me shprehjen e shkruar nn thonjza:
"D:/Libra/Koha.txt"
M sakt, me shprehjen:
D:/Libra/
ktu nnkuptohet shtegu ku vendoset fajlli. Prapashtesa .txt e fajllit te shembulli i dhn m sipr sht zgjedhur lirisht, meq kemi t bjm me fajll tekstual. Por, kjo prapashtes mund t merret si .doc, ose edhe e fardoshme. Prmes pjess ios::out, jepet modi i hapjes s fajllit dhe kompjuteri njoftohet se te fajlli q hapet do t shkruhen t dhna, prkatsisht fajlli do t prdoret pr dalje. Shkruarja n fajll e vlerave t variablave k dhe x realizohet prmes komands:
Shkruaj << k << ' ' << x;
e cila sht e ngjashme me komandn e zakonshme cout, q shfrytzohet pr shtypje n ekran. Ktu, me zbrazsirn e prfshir nn thonjza sht parapar q mes vlerave t variablave k dhe x n disk t lihet nj vend i zbrazt. N fund t programit, me komandn:
cout << "\nShkruarja n fajll prfundoi" << "\n\n";
n ekran shtypet mesazhi i shnuar nn thonjza, pr t na njoftuar se shkruarja n fajll ka prfunduar. Nse fajlli Koha.txt hapet me ndonj program pr prpunim t tekstit, p.sh., si sht programi Microsoft Notepad, n t do t shihen vlerat e variablave k dhe x, t shkruara me nj zbrazsir mes tyre, ashtu si sht dhn n Fig.7.2. Fig.7.2 Prmbajtja e fajllit Koha.txt pas ekzekutimit t programit file1
320 Programimi i orientuar n objekte Zbrazsira mes dy numrave lihet me qllim q ato t dallohen mes vete, prkatsisht t mos duken si nj numr, gj q ka rndsi gjat leximit t tyre nga fajlli. Fajlli mund t hapet pr shkruarje edhe duke e krijuar objektin e rrjedhs
r prkatse prmes komands: ofstream r("f");
prkatsisht pa e deklaruar modin e hapjes s tij ios::out, sepse kur shfrytzohet klasa ofstream, ky mod sht i nnkuptuar (ang. default). N shembullin e programit t dhn m sipr, kjo komand do t shkruhet:
ofstream Shkruaj("D:/Libra/Koha.txt");
Gjat hapjes s fajllit prmes komands n fjal, nse fajlli q hapet ka ekzistuar m par, kompjuteri s pari e fshin dhe pastaj e rihap at. Pasi t prfundoj shfrytzimi i fajllit, ai duhet t mbyllet prmes funksionit close, i cili n form t prgjithshme shkruhet:
r.close();
ku me r sht shnuar rrjedha e deklaruar si objekt i klass s shfrytzuar pr hapje t fajllit. Kshtu, p.sh., te programi file1, q u dha m sipr, komanda pr mbyllje t fajllit t shfrytzuar do t duket:
Shkruaj.close();
Kjo komand duhet t vendoset n pjesn e fundit t programit, pasi t prfundoj shkruarja e t dhnave dhe qasja e mtejshme n fajll t jet e panevojshme. Nse nuk shfrytzohet kjo komand, kompjuteri automatikisht do ta mbyll fajllin, kur prfundon ekzekutimi i tij.
Memoria ndrmjetsuese
Gjat shkruarjes s t dhnave n fajll, ato fillimisht regjistrohen n nj memorie ndihmse, ose n memorie ndrmjetsuese, prkatsisht n bafer (ang.buffer). Meq baferi ka nj madhsi t kufizuar, pas mbushjes s tij, t dhnat prej baferit prcillen n fajll. Por, duke e prdorur manipulatorin endl, prve q shkruhet n fajll karakteri manipulatorit pr kalim n rresht t ri, kompjuteri e zbraz edhe baferin, duke i shkruar t dhnat n fajll, pavarsisht se a sht mbushur ai me t dhna.
Fajllat 321 Baferi mund t zbrazet edhe duke e shfrytzuar funksionin flush. Por, pr dallim nga manipulatori endl, gjat shfrytzimit t ktij funksioni n fajll nuk shkruhet karakteri pr kalim n rresht t ri. Prdorimi i funksionit flush, ose i manipulatorit endl pr zbrazje t baferit lidhet me rritjen e siguris s shkruarjes s t dhnave n fajll. Kjo ka rndsi veanrisht n kushtet e ndrprerjes s pakontrolluar t puns s kompjuterit, p.sh., kur ndrpritet furnizimi me energji elektrike. N ato raste, t dhnat q ruhen n bafer nuk do t shkruhen n fajll, sepse me ndrprerjen e puns s kompjuterit, prmbajtja e baferit fshihet. N programin file1 t dhn m sipr, prdorimi i manipulatorit endl dhe i funksionit flush do t dukej ashtu si sht dhn n 3 versionet vijuese t komands pr shkruarje n fajll.
Shkruaj << << << << k ' ' x flush;
Shkruaj << k << ' ' << x; Shkruaj.flush();
Shkruaj << << << << k ' ' x endl;
Baferi ndrmjetsues zbrazet dhe komplet prmbajtja e tij prcillet n disk edhe kur mbyllet fajlli, qoft prmes komands close, ose kur fajlli mbyllet automatikisht n fund t programit.
Leximi nga fajlli

T dhnat e regjistruara n fajll mund t lexohen pasi paraprakisht t hapet fajlli pr lexim. Pr krijimin e objektit dhe hapjen e fajllit, komanda prkatse n formn e saj themelore shkruhet:
ifstream r("f",ios::in);
ku jan:
r - rrjedha e deklaruar si objekt i klass ifstream.

f - emri i fajllit q hapet. ios::in - modi i hapjes s fajllit pr lexim.
Si edhe gjat hapjes s fajllit pr shkruarje, me emrin e fajllit f nnkuptohet edhe komplet shtegu n t cilin vendoset fajlli. Shembull Programi file2, prmes s cilit nga fajlli Koha.txt, lexohen vlerat 77 dhe 58.94 t regjistruara paraprakisht me ekzekutimin e programit file1 t dhn m sipr.
// Programi file2 #include <iostream> #include <fstream> using namespace std; int main() { int k; double x; ifstream Lexo("D:/Libra/Koha.txt",ios::in); Lexo >> k >> x; cout << << << << << << return 0; } "\nVlerat e lexuara nga fajlli" "\n\n k=" k "\n x=" x "\n\n";
Ktu, pr hapje t fajllit Koha.txt n modin pr lexim, i cili sht krijuar gjat ekzekutimit t programit file1, sht shfrytzuar komanda:
ifstream Lexo("D:/Libra/Koha.txt",ios::in);
prmes s cils deklarohet rrjedha Lexo si objekt i klass ifstream. Rezultati q shtypet n ekran pas ekzekutimit t programit t dhn do t duket si n Fig.7.3.
Fajllat 323

file2
Fajlli mund t hapet pr lexim edhe duke e krijuar objektin prkats prmes komands:
ifstream r("f");
pa e deklaruar edhe modin e hapjes s tij ios::in, sepse, kur shfrytzohet klasa ifstream, ky mod sht i nnkuptueshm. N shembullin e programit t dhn m sipr, komanda n fjal shkruhet:
ifstream Lexo("D:/Libra/Koha.txt");
Nuk sht e thn q variablat e shfrytzuara gjat leximit t t dhnave nga fajlli t quhen njlloj me variablat q jan shfrytzuar pr shkruarjen e tyre. Por, nnkuptohet se tipet e tyre duhet t zgjedhen ashtu q t'u prkasin vlerave q lexohen. Edhe fajllat e hapur pr lexim, n fund duhet t mbyllen duke e shfrytzuar funksionin close, ashtu si u shpjegua m sipr. Kshtu, p.sh., pr mbylljen e fajllit t shfrytzuar pr lexim n programin file2, funksioni duket:
Lexo.close();
Kontrollimi i hapjes s fajllave

Tentimi pr hapje t fajllave mund t mos jet i suksesshm. Gjat ksaj, me qllim t kontrollimit t gabimeve eventuale n hapje t tyre, shfrytzohet komanda:
if(!r)
ku me r nnkuptohet rrjedha q i shoqrohet fajllit, prkatsisht objekti q krijohet gjat hapjes s tij. Shembull Versioni file2g i programit file2, prmes s cilit tregohet kontrollimi i hapjes s suksesshme t fajllit Koha.txt.

// Programi file2g #include <iostream> #include <fstream> using namespace std; int main() { int k; double x; ifstream Lexo("D:/Libra/Koha.txt",ios::in); if(!Lexo) { cout << "\nGabim gjat hapjes s fajllit"; goto Fundi; } Lexo >> k >> x; cout << << << << << Fundi: cout << return 0; } "\nVlerat e lexuara nga fajlli" "\n\n k=" k "\n x=" x; "\n\n";
Si shihet nga pjesa e theksuar e programit, nse vlera e shprehjes brenda kllapave t komands if sht true, n ekran do t shtypet mesazhi:
Gabim gjat hapjes s fajllit
dhe prmes komands goto Fundi, ekzekutimi i programit prfundon. Q ta vrejm gjenerimin e mesazhit n fjal, p.sh., mund t marrim se n komandn pr hapje t fajllit, n vend t diskut D: gabimisht sht shnuar disku C: n t cilin nuk ekziston folderi Libra, kshtu:
ifstream Lexo("C:/Libra/Koha.txt",ios::in);
Nnkuptohet se me efekt t njjt, shprehja brenda kllapave t komands

if mund t shkruhet edhe n kto forma:
Fajllat 325
if(!Lexo==true)
dhe
if(Lexo==false)
Gjat shtypjes n ekran t mesazhit pr gabim, mund t shfrytzohet edhe komanda speciale cerr, n kt mnyr:
cerr << "\nGabim gjat hapjes s fajllit";
Kjo komand sht e ngjashme me komandn cout, e cila sht m e prgjithshme, sepse prve pr shtypje n ekran, shfrytzohet edhe pr shkruarje n pajisje t tjera (p.sh. n disk, n printer etj.). N komponentet e klasave q prdoren pr operim me fajlla ekziston edhe funksioni is_open prmes s cilit mund t kontrollohet hapja e suksesshme e fajllave. Kshtu, p.sh., te programi file2g, i dhn m sipr, prdorimi i funksionit n fjal do t duket:
if (!Lexo.is_open()) { cout << "\nGabim gjat hapjes s fajllit"; goto Fundi; }
Deklarimi i objektit para hapjes

Fajlli mund t hapet pr shkruarje pasi paraprakisht t jet deklaruar objekti prkats i klass ofstream, n kt mnyr:
ofstream r; r.open("f",ios::out);
ku jan:
r - rrjedha e deklaruar si objekt i klasave pr pun me fajlla. f - emri i fajllit q hapet. ios::out - modi i hapjes s fajllit pr shkruarje.
Shembull
Versioni file1a i programit file1, t dhn m sipr, tek i cili para se t hapet fajlli Koha.txt deklarohet rrjedha Shkruaj si objekt i klass ofstream.
// Programi file1a #include <iostream> #include <fstream> using namespace std; int main() { ofstream Shkruaj; int k=77; double x=58.94; Shkruaj.open("D:/Libra/Koha.txt",ios::out); Shkruaj << k << ' ' << x; cout << "\nShkruarja n fajll prfundoi" << "\n\n"; return 0; }
Ktu, mund t shfrytzohet versioni i hapjes s fajllit pa e shnuar modin

ios::out, kshtu: ofstream r; r.open("f");
sepse, si u tha edhe m sipr, ai nnkuptohet, meq shfrytzohet klasa ofstream. Edhe gjat leximit, fajlli mund t hapet duke e krijuar paraprakisht rrjedhn prkatse si objekt t klass ifstream:
ifstream r; r.open("f",ios::in);
Shembull
Versioni file2a i programit file2 t dhn m sipr, tek i cili para se t hapet fajlli Koha.txt deklarohet objekti Lexo i klass ifstream.
Fajllat 327
// Programi file2a #include <iostream> #include <fstream> using namespace std; int main() { ifstream Lexo; int k; double x; Lexo.open("D:/Libra/Koha.txt",ios::in); Lexo >> k >> x; cout << << << << << << return 0; } "\nVlerat e lexuara nga fajlli" "\n\n k=" k "\n x=" x "\n\n";
Nnkuptohet se para ekzekutimit t ktij programi, te fajlli Koha.txt duhet t regjistrohen t dhnat q lexohen, p.sh., duke e ekzekutuar paraprakisht programin file1a. Rezultati n ekran, pas ekzekutimit t ktij versioni t programit do t duket si n Fig.7.3. Edhe ktu mund t shfrytzohet versioni pa e shnuar modin e hapjes ios::in, kshtu:
ifstream r; r.open("f");
sepse ai nnkuptohet, meq sht shfrytzuar klasa ifstream. N parktik, zakonisht, prdoren format e dhna ktu pr hapje t fajllave pasi t jen krijuar rrjedhat si objekte t klasave prkatse. Kto forma jan t domosdoshme, kur brenda nj programi fajllat rihapen pasi paraprakisht t jen mbyllur, sepse mnyra e krijimit t rrjedhave gjat hapjes s fajllave, pr shkak t dyfishimit t objekteve, e imponon nevojn e shfrytzimit t rrjedhave me emra t tjer.
Qasja te fajllat n unaz

Komandat pr shkruarje n fajlla dhe n lexim prej tyre mund t prfshihen edhe brenda unazave, pasi paraprakisht deklarohen rrjedhat si objekte t klasave prkatse dhe t jen hapur fajllat.
Shkruarja n unaz
Me qllim t shkruarjes, p.sh., n fajlla t t dhnave q fitohen prmes llogaritjeve t ndryshme brenda unazave, komandat pr shkruarje n fajlla mund t prfshihen n strukturat e tyre. Shembull Programi file3, prmes s cilit n fajllin Rrethi.txt regjistrohen vlerat e llogaritura t siprfaqes s dhe t perimetrit p t rrethit, pr vlera t ndryshme t rrezes r, mes vlers fillestare a=3 dhe vlers prfundimtare b=7, duke e ndryshuar me hapin h=0.5.
// Programi file3 #include <iostream> #include <fstream> using namespace std; int main() { double a=3,b=7,h=0.5,pi=3.1415926,r,s,p; ofstream Shkruaj("D:/Libra/Rrethi.txt",ios::out); for(r=a;r<=b;r=r+h) { s=2*pi*r; p=pi*r*r; Shkruaj << r << ' ' << s << ' ' << p << endl; } cout << "\nShkruarja n fajll prfundoi" << "\n\n";
Fajllat 329
return 0; }
Nse pas ekzekutimit t programit t dhn hapet fajlli prmes programit Microsoft Notepad, n t do t shihen vlerat e shkruara, ashtu si sht dhn n Fig.7.4.
Fig.7.4 Prmbajtja e fajllit Rrethi.txt pas ekzekutimit t programit file3 Ktu, n do rresht t fajllit jan shkruar 3 vlera: rrezja r, siprfaqja s dhe perimetri prkats p, t ndara mes vete me nga nj zbrazsir. Por, nse n vend t manipulatorit endl, n fund t komands pr shkruarje n fajll, nn thonjza shnohet nj zbrazsir:
Shkruaj << << << << << << r ' ' s ' ' p ' ';
t dhnat n fajll do t vendosen n nj rresht t vetm. N fakt, kur hapet fajlli Rrethi.txt prms tekstprocesorit, paraqitja n rreshta t veant e t dhnave do t varet nga prania e simbolit pr kalim n rreshta t rinj.
Shfrytzimi i manipulatorve
Me qllim t shkruarjes n fajll n numr t caktuar vendesh, mund t shfrytzohet manipulatori setw. Gjat ksaj, n fillim t programit duhet t vendoset komanda paraprocesorike me fajllin iomanip. Shembull Versioni file3a i programit file3 t dhn m sipr, tek i cili gjat shkruarjes s t dhnave n fajllin Rrethi.txt shfrytzohet edhe manipulatori setw.
// Programi file3a #include <iostream> #include <fstream> #include <iomanip> using namespace std; int main() { double a=3,b=7,pi=3.1415926,r,s,p; ofstream Shkruaj("D:/Libra/Rrethi.txt",ios::out); for(r=a;r<=b;r=r+0.5) { s=2*pi*r; p=pi*r*r; Shkruaj << setw(4) << r << ' ' << setw(7) << s << ' ' << setw(7) << p << endl; } cout << "\nShkruarja n fajll prfundoi" << "\n\n"; return 0; }
Nse n kt rast, pas ekzekutimit t programit t dhn hapet fajlli prmes programit Microsoft Notepad, prmbajtja e fajllit do t duket si n Fig.7.5.
Fig.7.5 Prmbajtja e fajllit Rrethi.txt pas ekzekutimit t programit file3a
Fajllat 331
Vlerat n fajllin Rrethi.txt mund t shkruhen edhe me nj precizitet t caktuar, duke e shfrytzuar versionin file3b t programit file3a, n t cilin te komanda pr shkruarje n fajll prdoren edhe manipulatort fixed dhe setprecision , p.sh., ashtu si sht dhn n vijim.
Shkruaj << << << << << << << << << << << fixed setprecision(2) setw(4) r ' ' setw(7) s ' ' setw(7) p endl;
Pas ksaj, nse ekzekutohet programi file3b, t dhnat brenda fajllit do t shkruhen me dy vende pas piks dhjetore (shih Fig.7.6), t rrumbullaksuara n baz t rregullave t njohura pr rrumbullaksim.
Fig.7.6 Prmbajtja e fajllit Rrethi.txt pas ekzekutimit t programit file3b
Leximi n unaz
Pr leximin e t dhnave q jan shkruar n m shum rreshta t nj fajlli duhet t shfrytzohet unaza prkatse, e ngjashme me unazn q sht shfrytzuar gjat shkruarjes s tyre n fajll. Shembull Programi file4 pr leximin e t dhnave t regjistruara n fajllin Rrethi.txt, t cilat jan shkruar paraprakisht n fajll prmes programit file3b.
// Programi file4 #include <iostream> #include <fstream> #include <iomanip> using namespace std; int main() { double r,s,p; int i; ifstream Leximi("D:/Libra/Rrethi.txt",ios::in); cout << << << << "\nT dhnat e lexuara nga fajlli" "\n\n r s p\n\n" fixed setprecision(2);
for(i=1;i<=9;i++) { Leximi >> r >> s >> p; cout << << << << << << << setw(8) r setw(7) s setw(7) p "\n";
} cout << endl; return 0; }
Ktu, pr leximin e 9 rreshtave me t dhna n fajllin Rrethi.txt sht shfrytzuar unaza me variabln i, vlerat e s cils ndryshojn mes vlers 1 dhe 9, me hapin 1. Pas ekzekutimit t programit, rezultati q shtypet n ekran prmes komands cout do t duket si n Fig.7.7.
Fajllat 333
Fig.7.7 Pamja e ekranit pas ekzekutimit t programit file4 Por, zakonisht, nuk dihet se sa t dhna jan shkruar n fajll. Prandaj, pr leximin e t dhnave nga fajlli, zakonisht shfrytzohet unaza while, ekzekutimi i s cils prsritet derisa nuk arrihet n fund t fajllit. Shembull Versioni file4a i programit file4, tek i cili pr leximin e t dhnave t cilat jan regjistruara paraprakisht n fajllin Rrethi.txt shfrytzohet unaza while.
// Programi file4a #include <iostream> #include <fstream> #include <iomanip> using namespace std; int main() { double r,s,p; ifstream Lexo("D:/Libra/Rrethi.txt",ios::in); cout << << << << "\nT dhnat e lexuara nga fajlli" "\n\n r s p\n\n" fixed setprecision(2);
while (!Lexo.eof())

{ Lexo >> r >> s >> p; if (!Lexo.eof()) cout << setw(8) << r << setw(7) << s << setw(7) << p << "\n"; } cout << endl; return 0; }
N programin e dhn, procedura e leximit t t dhnave nga fajlli do t vazhdoj derisa sht false vlera brenda kllapave t komands:
while (!Lexo.eof())
prkatsisht, derisa pointeri i pozits n fajll nuk tregon n fundin e tij, kur vlera e funksionit eof bhet true. Kjo do t thot se komanda n fjal mund t shkruhet edhe kshtu:
while (!Lexo.eof()==true)
gj q nnkuptohet nga kompjuteri. Kur mbrrihet n fund t fajllit, funksionit eof i shoqrohet vlera -1, e cila vler nuk sht e shkruar n fajll. Prmes komands:
if (!Lexo.eof())
para shtypjes n ekran t vlerave t lexuara, shqyrtohet se mos ndoshta gjat ekzekutimit t komands pr lexim sht arritur n fund t fajllit. Nse nuk shfrytzohet kjo komand, rreshti i fundit n tabeln me vlera do t shtypet dy her.
Flamujt e statusit
Gjat puns me fajlla mund t shfrytzohen flamujt e statusit (ang. status flags), t dhn n Fig.7.8, vlerat e t cilve lidhen me objektet e rrjedhave t fajllave.
Fajllat 335
Emri i flamurit
eofbit failbit badbit hardfail goodbit
Tregon arritjen n fund t fajllit. dshtim gjat operimit. operim t gabueshm. gabim t pakorrigjueshm. operim t suksesshm (asnj flamur nuk ndryshohet).
Fig.7.8 Flamujt e statusit t objekteve t rrjedhave t fajllave Vlerat e flamujve t statusit merren prmes funksioneve t dhna n kolonn e par t tabels q shihet n Fig.7.9.
Funksioni eof() fail() bad() good() clear() Prdorimi
E jep vlern true, nse eofbit sht inicializuar. E jep vlern true, nse inicializohet njri nga flamujt: failbit, badbit ose hardfail. E jep vlern true, nse inicializohet njri nga flamujt: badbit ose hardfail. E jep vlern true, nse nuk inicializohet asnj flamur, prkatsisht nse do gj sht n rregull. I fshin vlerat n t gjith flamujt e statusit t rrjedhs.
Fig.7.9 Funksionet pr marrje t vlerave t flamujve t statusit Shembull Versioni file4b i programit file4a, n t cilin brenda unazs urdhrohet shtypja e vlerave t funksioneve eof, fail dhe good.
// Programi file4b #include <iostream> #include <fstream> #include <iomanip> using namespace std; int main() { double r,s,p; ifstream Lexo("D:/Libra/Rrethi.txt",ios::in);

cout << << << << "\nT dhnat e lexuara nga fajlli" "\n\n r s p\n\n" fixed setprecision(2);
while (!Lexo.eof()) { Lexo >> r >> s >> p; cout << " " << Lexo.eof() << " " << Lexo.fail() << " " << Lexo.good() ; if (!Lexo.eof()) cout << setw(6) << r << setw(7) << s << setw(7) << p << "\n"; } cout << endl; return 0; }
Nse ekzekutohet programi i dhn, n tri kolonat e para do t shtypen vlerat e funksioneve eof, fail dhe good, ashtu si shihet n Fig.7.10.
Fig.7.10 Pamja e ekranit pas ekzekutimit t programit file4b
Nga rezultatet e shtypura n tri kolonat e para shihet se gjat gjith kohs, kur nga fajlli lexohen t dhnat, n ekran shtypen vlerat 0, 0 dhe 1. Kjo do t
Fajllat 337 thot se funksionet eof dhe fail i japin vlerat false, sepse nuk sht mbrri n fund t fajllit dhe leximi nuk ka dshtuar. Kurse vlera e funksionit good sht true, sepse gjat ksaj kohe leximi i t dhnave sht n rregull. N fund, kur lexohet komplet prmbajtja e fajllit, vlerat e funksioneve n fjal ndryshojn n 1, 1 dhe 0, gj q sht rezultat i ndryshimit t vlerave t flamujve prkats, mbshtetur n logjikn e shpjeguar m sipr. Komanda e unazs while mund t shkruhet edhe n kt mnyr:
while(Lexo && !Lexo.eof())
Me pjesn e par t ksaj komande prcaktohet q ekzekutimi i unazs t vazhdoj derisa rrjedha Lexo e fajllit sht true, prndryshe duhet t dilet nga unaza.
Shkruarja dhe leximi n nj program

Brenda nj programi, prve q mund t shkruhen t dhnat n fajll, njkohsisht ato edhe mund t lexohen.
Shfrytzimi i dy objekteve t veanta

Pr shkruarjen e t dhnave n fajll dhe leximin e tyre prej fajlli mund t shfrytzohen dy objekte t veanta - njri pr shkruarje dhe tjetri pr lexim. Shembull Programi file5, prmes s cilit n fajllin Rrethi.txt, s pari shkruhen t dhnat e rrezes r, t siprfaqes s dhe t perimetrit p t rrethit. Pastaj, n pjesn e dyt t programit lexohen t dhnat e shkruara n fajllin n fjal dhe t njjtat shtypen n ekran.
// Programi file5 #include <iostream> #include <fstream> #include <iomanip> using namespace std; int main() { double a=3,b=7,h=0.5,pi=3.1415926,r,s,p; // --------------- Shkruarja n fajll ---------------------ofstream Shkruaj("D:/Libra/Rrethi.txt",ios::out);

for(r=a;r<=b;r=r+h) { s=2*pi*r; p=pi*r*r; Shkruaj << fixed << setprecision(2) << setw(4) << r << ' ' << setw(7) << s << ' ' << setw(7) << p << endl; } cout << "\nShkruarja n fajll prfundoi" << "\n"; Shkruaj.close(); // --------------- Leximi prej fajllit --------------------ifstream Lexo("D:/Libra/Rrethi.txt",ios::in); cout << << << << "\nT dhnat e lexuara nga fajlli" "\n\n r s p\n\n" fixed setprecision(2);
while (!Lexo.eof()) { Lexo >> r >> s >> p; if (!Lexo.eof()) cout << setw(8) << r << setw(7) << s << setw(7) << p << "\n"; } cout << endl; return 0; }
Fajllat 339 Ktu, n t vrtet, jan bashkuar n nj program dy versionet e programeve file3b dhe file4a t dhna m sipr. Por, para hapjes s fajllit pr lexim, ai sht mbyllur, duke e shfrytzuar komandn:
Shkruaj.close();
gj q nuk sht e domosdoshme. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket ashtu si sht dhn n Fig.7.7.
Shfrytzimi i nj objekti t vetm

Gjat hapjes s fajllit ekzistues, objekti prkats mund t deklarohet duke e shfrytzuar klasn fstream, n kt form:
fstream r("f",ios::out|ios::in);
ku jan:
r - rrjedha e deklaruar si objekt i klasave pr pun me fajlla. f - emri i fajllit q hapet. ios::out - modi i hapjes s fajllit pr shkruarje. ios::in - modi i hapjes s fajllit pr lexim.
Pas ksaj, rrjedha r q krijohet mund t shfrytzohet si pr shkruarje ashtu edhe pr lexim. Radha e shkruarjes s modeve t hapjes s fajllit, n pjesn e fundit t komands s dhn m sipr, nuk ka rndsi. Shembull Programi file6, prmes s cilit n fajllin Koha.txt, s pari regjistrohen vlerat 77 dhe 58.94 t variablave k dhe x dhe pastaj t njjtat lexohen nga fajlli dhe shtypen n ekran.
// Programi file6 #include <iostream> #include <fstream> using namespace std; int main() { int k=77; double x=58.94; fstream Dita("D:/Libra/Koha.txt",ios::in|ios::out);

// ----------- Shkruarja n fajll ----------------------Dita << k << ' ' << x; cout << "\nShkruarja n fajll prfundoi" << "\n"; // ----------- Leximi nga fajlli -----------------------Dita.seekg(0); Dita >> k >> x; cout << << << << << << << return 0; } "\nVlerat e lexuara nga fajlli" "\n\n" " k=" k "\n x=" x "\n\n";
N program, n fakt jan bashkuar pjest e programeve file1 dhe file2 t dhna m par. Por, ktu, duke e shfrytzuar klasn fstream, krijohet objekti Dita dhe hapet fajlli Koha.txt n dy mode - pr shkruarje dhe pr lexim. Nse ekzekutohet programi i dhn, t dhnat q regjistrohen n fajll do t duken ashtu si sht dhn n Fig.7.2. Kurse, rezultati i leximit nga fajlli n ekran do t shtypet ashtu si sht dhn n Fig.7.3. Nnkuptohet se mund t shfrytzohet edhe versioni i hapjes s fajllit pr shkruarje dhe lexim, tek i cili do t shfrytzohet rrjedha r e klass fstream e deklaruar m par, kshtu:
fstream r; r.open("f",ios::out|ios::in);
Praktikisht, n shembullin e programit t dhn m sipr, deklarimi i objektit Dita dhe shfrytzimi i tij n hapjen e fajllit Koha.txt do t duket:
fstream Dita; Dita.open("D:/Libra/Koha.txt",ios::out|ios::in);
Fajllat 341
Tekstet n fajlla
N fajlla mund t shkruhen dhe t lexohen edhe tekste, prkatsisht stringje. Shembull Programi file7 prmes s cilit tregohet shkruarja n fajllin Dita.txt e nj fjalie dhe leximi i saj prmes variabls g t tipit string.
// Programi file7 #include <iostream> #include <fstream> #include <string> using namespace std; int main() { // -------------- Shkruarja n fajll ------------------ofstream Shkruaj("D:/Libra/Dita.txt",ios::out); Shkruaj << "Programimi i orientuar n objekte"; cout << "\nShkruarja n fajll prfundoi" << "\n"; Shkruaj.close(); // -------------- Leximi nga fajlli -------------------string g; fstream Lexo("D:/Libra/Dita.txt",ios::in); cout << "\nTeksti q lexohet nga fajlli\n\n"; while (!Lexo.eof()) { Lexo >> g; cout << g << endl; } cout << "\nLeximi nga fajlli prfundoi" << "\n\n"; return 0; }
342 Programimi i orientuar n objekte Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.7.11.

file7
Gjat leximit nga fajlli, te stringu g lexohen me radh fjalt e prfshira n fjali, gj q shihet edhe nga shtypja e tyre n ekran. N fjalt q lexohen nuk prfshihen edhe zbrazsirat, sepse ato kompjuteri i interpreton si hapsira ndarse mes t dhnave t veanta, e q n kt rast jan fjalt e prfshira n fjali. Kjo m s miri shihet nga rezultati q do t shtypet (shih Fig.7.12), nse ekzekutohet versioni file7a i programit file7, tek i cili n fund t komands pr shtypje n ekran nuk figuron manipulatori endl:
// Programi file7a ........................................... while (!Lexo.eof()) { Lexo >> g; cout << g; } cout << "\n\nLeximi nga fajlli prfundoi" << "\n\n"; return 0; }
Fig.7.12 Pamja e ekranit pas ekzekutimit t versionit t programit file7a
Fajllat 343 Q fjalia t shtypet n ekran n nj rresht dhe me zbrazsira mes fjalve t veanta, gjat shtypjes s do pjese t tekstit t lexuar duhet t shtypet edhe nj zbrazsir. Shembull Pjesa e fundit e versionit file7b t programit file7, prmes s cilit gjat shtypjes s fjalis s lexuar nga fajlli parashihet edhe shtypja e zbrazsirs mes fjalve t veanta.
// Programi file7b ........................................... while (!Lexo.eof()) { Lexo >> g; cout << g << ' '; } cout << "\n\nLeximi nga fajlli prfundoi" << "\n\n"; return 0; }
Nse ekzekutohet versioni i dhn i programit, rezultati n ekran do t duket ashtu si sht dhn n Fig.7.13.
Fig.7.13 Pamja e ekranit pas ekzekutimit t versionit t programit file7b
Tekstet dhe numrat n fajlla

Vlerat numerike q shkruhen n fajll mund t shoqrohen edhe me tekste, plotsisht njlloj si shoqrohen edhe gjat shtypjes n ekran. Por, ktu duhet pasur kujdes q mes t dhnave t veanta t lihet s paku nj zbrazsir, ashtu q, si u tha edhe m par, kompjuteri t'i dalloj t dhnat e veanta. Shembull Programi file8, prmes s cilit n fajllin Koha.txt regjistrohen vlerat 863 dhe 58.94 t variablave k dhe x, t shoqruara me tekste.
// Programi file8 #include <iostream> #include <fstream> using namespace std; int main() { int k=863; double x=58.94; ofstream Shkruaj("D:/Libra/Koha.txt",ios::out); Shkruaj << << << << "k= " k " x= " x;
cout << "\nShkruarja n fajll prfundoi" << "\n\n"; return 0; }
Pas ekzekutimit t programit t dhn, prmbajtja e fajllit Koha.txt do t duket si n Fig.7.14. Fig.7.14 Prmbajtja e fajllit Koha.txt pas ekzekutimit t programit file8 Prej ktu shihet se tekstet e shnuara nn thonjza si dhe vlerat numerike t variablave shkruhen n fajll, duke i llogaritur si tekste edhe zbrazsirat e prfshira nn thonjza. Pr leximin e t dhnave tekstuale dhe numerike, t shkruara n fajll, duhet t shfrytzohen variabla numerike t tipeve prkatse dhe variablave t tipit string. Shembull Versioni file8a i programit file8, prmes s cilit nga fajlli Koha.txt lexohen t dhnat e shkruara prmes programit file8 dhe t njjtat shtypen n ekran n rreshta t veant.
// Programi file8a #include <iostream>
Fajllat 345
#include <fstream> #include <string> using namespace std; int main() { int k; double x; string s1,s2; ifstream Lexo("D:/Libra/Koha.txt",ios::in); Lexo >> >> >> >> cout << << << << << << << << << return 0; } s1 k s2 x; "\nT dhnat e lexuara nga fajlli\n\n" s1 "\n" k "\n" s2 "\n" x "\n\n";
N program, pr leximin e vlerave numerike jan shfrytzuar variablat k dhe x, t njjta me ato q u shfrytzuan te programi file8 gjat shkruarjes s tyre n fajll. Por, ato mund t quhen edhe ndryshe, gj q nuk ka rndsi. Kurse pr leximin e dy teksteve jan shfrytzuar variablat s1 dhe s2 t tipit string. Informatat e lexuara shtypen n ekran prmes komandave t zakonshme pr shtypje, ashtu q rezultati n ekran do t duket si n Fig.7.15.
Fig.7.15 Pamja e ekranit pas ekzekutimit t versionit t programit file8a Gjat leximit t vlerave numerike t cilat n fajll ruhen si sekuenca simbolesh tekstuale, kompjuteri i konverton ato n numra, duke e pasur parasysh tipin e variablave ku ruhen vlerat e lexuara.
Rezultati n ekran mund t shtypet edhe ndryshe, ashtu q t ket nj pamje t zakonshme. Shembull Pjesa e fundit e versionit file8b t programit file8a, tek i cili gjat shtypjes s t dhnave n ekran sht shfrytzuar nj form m e prshtatshme e komands pr shtypje.
// Programi file8b .............................................. cout << "\nT dhnat e lexuara nga fajlli\n\n" << s1 << k << " " << s2 << x << "\n\n"; return 0; }
Nse ekzekutohet versioni n fjal i programit, n nj rresht t ekranit si rezultat do t shtypen k=863 dhe x=58.94. Pr leximin nga fajlli mund t shfrytzohet nj string, pavarsisht nga ajo se t dhnat n fajll jan shkruar si stringje dhe vlera numerike. Shembull Versioni file8b i programit file8 pr leximin e t dhnave t shkruara n fajllin Koha.txt prmes programit file7, n stringun g dhe t njjtat shtypen n ekran.
// Programi file8b #include <iostream> #include <fstream> #include <string> using namespace std; int main() { string g; fstream Lexo("D:/Libra/Koha.txt",ios::in); cout << "\nT dhnat e lexuara nga fajlli\n\n";
Fajllat 347
while (!Lexo.eof()) { Lexo >> g; cout << g << ' '; } cout << "\n\nLeximi nga fajlli prfundoi" << "\n\n"; return 0; }
Rezultati q do t shihet n ekran pas ekzekutimit t programit file8b do t duket si n Fig.7.16.
Fig.7.16 Pamja e ekranit pas ekzekutimit t versionit t programit file8b Ktu, sht lexuar dhe sht shtypur n ekran komplet prmbajtja e fajllit, prfshir edhe zbrazsirat q jan ln mes t dhnave t veanta.
Shkruarja dhe leximi i karaktereve

Pr shkruarjen e t dhnave n fajll dhe leximin e tyre nga fajlli si karaktere, mund t shfrytzohen funksionet put dhe get. N form t prgjithshme, versionet themelore t ktyre dy funksioneve duken:
r.put(c); r.get(c);
ku jan:
r - rrjedha e deklaruar si objekt i klasave pr pun me fajlla. c - karakteri q shkruhet n fajll, ose lexohet nga fajlli.
Shembull
Programi file9, prmes s cilit n fajllin Koha.txt shkruhet teksti, i cili ruhet n stringun A, duke i shkruar nj nga nj karakteret e prfshir n string.
// Programi file9 #include <iostream>

#include <fstream> #include <string> using namespace std;
int main() { int i; double k; string A="Programimi i orientuar n objekte"; ofstream Shkruaj("D:/Libra/Koha.txt",ios::out); k=A.size(); for (i=0;i<k;i++) Shkruaj.put(A[i]); cout << "\nShkruarja n fajll prfundoi" << "\n\n"; return 0; }
N program, brenda unazs for sht prfshir komanda:

Shkruaj.put(A[i]);
prmes s cils shkruhen n fajll shronjat e veanta t prfshira n stringun A. Nse pas ekzekutimit t programit t dhn hapet fajlli Koha.txt duke e shfrytzuar programin Microsoft Notepad, prmbajtja e tij do t duket ashtu si sht dhn n Fig.7.17. Fig.7.17 Prmbajtja e fajllit Koha.txt pas ekzekutimit t programit file9 Unaza pr shkruarje n fajll mund t realizohet edhe pa e shfrytzuar variabln k n t ciln ruhet gjatsia e stringut A:
for (i=0;A[i]!='\0';i++) Shkruaj.put(A[i]);
Gjat ksaj, prfundimi i ekzekutimit t unazs sht prcaktuar me karakterin zero '\0', i cili gjendet n fund t stringut A.
Fajllat 349
Prmbajtja e fajllit mund t lexohet duke i lexuar t dhnat si karaktere t veanta.
Shembull
Programi file10, prmes s cilit lexohet prmbajtja e fajllit Koha.txt pasi n fajll t jet shkruar fjalia e prmendur m sipr, duke e ekzekutuar programin file9.
// Programi file10 #include <iostream> #include <fstream> using namespace std; int main() { char z; ifstream Lexo("D:/Libra/Koha.txt",ios::in); cout << "\nFjalia q lexohet nga fajlli\n\n"; while(!Lexo.eof()) { Lexo.get(z); if(!Lexo.eof()) cout << z; } cout << "\n\nLeximi nga fajlli prfundoi" << "\n\n"; return 0; }
Ktu, brenda unazs pr lexim t prmbajtjes s fajllit sht prfshir komanda:

Lexo.get(z);
me t ciln lexohen nj nga nj shkronjat e fjalis s shkruar n fajll prmes variabls z. Gjat ksaj, rezultati q shtypet n ekran do t duket si n Fig.7.18.
Fig.7.18
350 Programimi i orientuar n objekte Pamja e ekranit pas ekzekutimit t versionit t programit file10 Nse duam q shkronjat e gjuhs shqipe t shkruhen sakt n ekran, pasi t lexohen nga disku, prkatsisht para se t shtypen n ekran, duhet t zvendsohen me simbolin , i cili fitohet prmes kombinimit t tasteve Alt+0137. Pr kt qllim, nj version i pjess s programit brenda unazs while mund t duket si n vijim.
while(!Lexo.eof()) { Lexo.get(z); if(!Lexo.eof()) { if(z=='') z=''; cout << z; } }
Njlloj duhet t veprohet edhe me shkronjat e tjera t alfabetit t gjuhs shqipe, t cilat nuk prfshihen n alfabetin ndrkombtar. Problemi i shkronjave t gjuhs shqipe mund t eliminohet edhe nse n fajll shkruhen simbolet t cilat n ekran shtypen sakt. Me kt nkuptohet se n shembullin e marr m sipr stringu q regjistrohet n disk duhet t shkruhet:
string A="Programimi i orientuar n objekte";
Plotsisht njlloj, si u shpjegua m sipr, do t lexohet prmbajtja e fardo fajlli n t cilin jan shkruar tekste, vlera numerike, programe etj.
Forma t tjera t unazave pr lexim

Unazat pr lexim t karaktereve nga disku dhe shtypje t tyre n ekran mund t shkruhen edhe ndryshe. Dy versione t tyre jan dhn n vijim.
while (Lexo) { Lexo.get(z); if(Lexo) cout << z; }
Fajllat 351 Ktu, n momentin kur mbrrihet n fund t fajllit, vlera logjike e rrjedhs
Lexo brenda kllapave t komands while sht false dhe prandaj ekzekutimi
i unazs prfundon.
while (Lexo.get(z)) { if(Lexo) cout << z; }
Edhe n kt rast, leximi ndrpritet duke e pasur parasysh logjikn e shpjeguar n versionin paraprak t unazs pr lexim.
Shfrytzimi i pointerve
Gjat shkruarjes n fajlla prmes funksionit put, ose gjat leximit nga fajllat prmes funksionit get, mund t shfrytzohen edhe pointert. Shembull Versioni file11 i programit file9, tek i cili gjat shkruarjes s fjalis n fajllin Koha.txt shfrytzohet pointeri a.
// Programi file11 #include <iostream> #include <fstream> using namespace std; int main() { char *a="Programimi i orientuar n objekte"; ofstream Shkruaj("D:/Libra/Koha.txt",ios::out); while (*a) Shkruaj.put(*a++); cout << "\nShkruarja n fajll prfundoi" << "\n\n"; return 0; }
352 Programimi i orientuar n objekte Nse pas ekzekutimit t programit t dhn hapet fajlli Koha.txt prmes programit Microsoft Notepad, prmbajtja e tij do t jet e njjt me at q shihet n Fig.7.17.
Leximi i rreshtave
Nga fajllat mund t lexohen rreshtat komplet, prfshir edhe zbrazsirat q mund t paraqiten brenda tyre. Gjithashtu, t dhnat n kto rreshta mund t lexohen deri n paraqitjen e nj simboli t caktuar. N t dy kto raste, pr leximin e t dhnave nga fajlli, shfrytzohet funksioni getline.
Leximi i komplet rreshtave

Pr leximin e t dhnave t cilat n fajlla shkruhen n rreshta t veant, mund t shfrytzohet funksioni getline, i cili n form t prgjithshme duket:
r.getline(g,m);
ku jan:
r - rrjedha e deklaruar si objekt i klasave pr pun me fajlla. g - variabla, prkatsisht baferi n t cilin ruhet teksti i lexuar. m - gjatsia e stringut q lexohet.
Gjat shfrytzimit t ktij funksioni, prej fajllave lexohen stringjet, prfshir edhe zbrazsirat, derisa nuk haset karakteri '\n' pr kalim n rresht t ri. Teksti i lexuar vendoset n baferin g, dhe gjatsia maksimale e tij mund t jet m-karaktere. Shembull Programi file12, prmes s cilit n fajllin Koha.txt fillimisht shkruhen 10 rreshta dhe pastaj t njjtit lexohen prmes funksionit getline dhe shtypen n ekran.
// Programi file12 #include <iostream> #include <fstream> using namespace std; int main() {
Fajllat 353
int i; // ---------- Shkruarja n fajll -----------------ofstream Shkruaj("D:/Libra/Koha.txt",ios::out); for (i=1;i<=10;i++) Shkruaj << " Rreshti i " << i << endl; cout << "\nShkruarja n fajll prfundoi" << "\n"; // ---------- Leximi nga fajlli ------------------const int m=20; char A[m]; ifstream Lexo("D:/Libra/Koha.txt",ios::in); cout << "\nTeksti q lexohet nga fajlli\n\n"; while (!Lexo.eof()) { Lexo.getline(A,m); cout << A << endl; } cout << "Leximi nga fajlli prfundoi" << "\n\n"; return 0; }
Ktu, prmes funksionit:

Lexo.getline(A,m);
prej fajllit lexohen komplet rreshtat me m s shumti m-karaktere. Gjat ksaj, t dhnat e lexuara ruhen te fusha A, e cila shrben si bafer me madhsi prej mkarakteresh. Rezultati q shtypet n ekran do t duket ashtu si shihet n Fig.7.19.
Fig.7.19 Pamja e ekranit pas ekzekutimit t versionit t programit file12 N programin e dhn, unaza pr leximin e rreshtave t veant mund t shkruhet edhe duke e prfshir funksionin getline brenda kllapave t komands while. Kshtu, pjesa e fundit e versionit file12a t programit file12, pas modifikimit n fjal, do t duket si n vijim.
// Programi file12a ....................................... while (Lexo.getline(A,m)) cout << A << endl; cout << "Leximi nga fajlli prfundoi" << "\n\n"; return 0; }
Nse ekzekutohet versioni i dhn i programit n fjal, rezultati n ekran do t jet i njjt me at q sht dhn n Fig.7.19.
Leximi deri n simbolin e caktuar

Rreshtat brenda fajllave mund t lexohen deri n paraqitjen e nj simboli t caktuar brenda tyre. Pr kt qllim funksioni getline n formn e tij t prgjithshme shkruhet:
r.getline(g,m,'s');
ku jan:
r g m s
rrjedha e deklaruar si objekt i klasave pr pun me fajlla. stringu q lexohet nga fajlli. gjatsia e stringut q lexohet. simboli kufitar deri tek i cili lexohet fjalia. Programi file13, prmes s cilit n fajllin Koha.txt fillimisht shkruhet nj fjali dhe pastaj, prmes funksionit getline lexohet vetm pjesa e saj deri te shkronja .
Shembull
Fajllat 355
// Programi file13 #include <iostream> #include <fstream> using namespace std; int main() { // -------- Shkruarja n fajll -----------------ofstream Alfa("D:/Libra/Koha.txt",ios::out); Alfa << "Programimi i orientuar n objekte" << endl; Alfa.close(); // -------- Leximi nga fajlli ------------------const int m=30; char A[m]; ifstream Beta("D:/Libra/Koha.txt",ios::in); cout << "\nTeksti q lexohet nga fajlli\n\n"; Beta.getline(A,m,''); cout << A << endl; cout << "\nLeximi nga fajlli prfundoi" << "\n\n"; return 0; }
Nse ekzekutohet programi i dhn, prmes komands:

Alfa << "Programimi i orientuar n objekte" << endl;
fillimisht n fajllin Koha.txt do t shkruhet fjalia e shnuar nn thonjza. Pastaj, pas mbylljes dhe rihapjes s fajllit, prmes funksionit:
Beta.getline(A,m,'');
te baferi A, me madhsi prej m-simbolesh, do t lexohet rreshti deri te shkronja e par . Kjo do t thot se nga fajlli do t lexohet nj pjes e fjalis q sht regjistruar n t, ashtu si shihet n Fig.7.20.
Fig.7.20
356 Programimi i orientuar n objekte Pamja e ekranit pas ekzekutimit t versionit t programit file13
Mode t hapjes s fajllave

Gjat hapjes s fajllave, pas emrit t tyre, prve dy modeve pr hapje, t cilt u prmendn m sipr, mund t shnohen edhe mode t tjera, t cilat shihen n kolonn e par t tabels s dhn n Fig.7.21, ose edhe kombinime t tyre. Modi i hapjes ios::in ios::out ios::trunc ios::app ios::nocreate ios::noreplace ios::ate ios::binary Prshkrimi Hapet fajlli pr hyrje. Hapet fajlli pr dalje. Nse fajlli ekziston q m par, prmbajtja e tij do t fshihet. Nse fajlli ekziston q m par, t dhnat e reja shtohen n fund t fajllit. Prndryshe, nse fajlli nuk ka ekzistuar, krijohet nj fajll i zbrazt. Nse fajlli nuk ekziston, hapja e tij dshton. Nse fajlli ekziston, hapja e tij dshton. Hapet fajlli dhe pointeri i pozicionit n fajll vendoset n fund t tij. Por, shkruarja ose leximi i t dhnave mund t bhet kudo n fajll. Hapet fajlli si fajll binar. Fig.7.21 Mode t hapjes s fajllave Modi trunc, pavarsisht se nuk shnohet, nga kompjuteri merret si mod i nnkuptuar gjat hapjes s fajllave nn modin out. Modi ate ka kuptim vetm nse prmbajtja e fajllit q hapet nuk fshihet. Kjo, p.sh., ndodh nse fajlli hapet q n t njkohsisht t mund t shkruhet dhe t lexohet, sepse n at rast fajlli i hapur nuk fshihet.
Kombinimet e modeve t hapjes

Fajllat, prve n modet e dhna n tabeln e Fig.7.21, mund t hapen edhe duke shfrytzuar kombinime t ktyre modeve. M par u dhan shembuj t hapjes s fajllave, duke i shfrytzuar njkohsisht modet out dhe in. Kurse
Fajllat 357 n vijim prmes shembujve do t shpjegohen hapjet e fajllave, me kombinime t modeve t hapjes s tyre. Shembull Programi file14, prmes s cilit tregohet shfrytzimi i njkohshm i modeve t hapjes s fajllit out dhe trunc.
// Programi file14 #include <iostream> #include <fstream> using namespace std; int main() { ofstream Shkruaj; int k=77; double x=58.94; Shkruaj.open("D:/Libra/Koha.txt",ios::out); Shkruaj << k << ' ' << x; cout << "\nShkruarja e par prfundoi" << "\n"; Shkruaj.close(); k=865; x=-643.47; Shkruaj.open("D:/Libra/Koha.txt",ios::out |ios::trunc); Shkruaj << k << ' ' << x; cout << "\nShkruarja e dyt prfundoi" << "\n\n"; return 0; }
N program, pas hapjes s par t fajllit, shkruhen vlerat 77 dhe 58.94, ashtu si sht treguar n Fig.7.2. Kurse, pas mbylljes dhe rihapjes s fajllit prmes komands:

Shkruaj.open("D:/Libra/Koha.txt",ios::out |ios::trunc);
s pari fshihet prmbajtja e tij dhe pastaj shkruhen vlerat e reja t variablave k dhe x, ashtu si shihet n Fig.7.22.
Fig.7.22 Prmbajtja e fajllit Koha.txt pas ekzekutimit t programit file14 dhe rishkruarjes s vlerave Nnkuptohet se komanda e dyt pr hapje t fajllit me efekt t njjt mund t shkruhet edhe m shkurt:
Shkruaj.open("D:/Libra/Koha.txt",ios::trunc);
Shembull
Versioni file15 i programit file14, prmes s cilit tregohet shfrytzimi i njkohshm i modeve t hapjes s fajllit out dhe app.
// Programi file15 #include <iostream> #include <fstream> using namespace std; int main() { ofstream Shkruaj; int k=77; double x=58.94; Shkruaj.open("D:/Libra/Koha.txt",ios::out); Shkruaj << k << ' ' << x << endl; cout << "\nShkruarja e par prfundoi" << "\n"; Shkruaj.close(); k=865;
Fajllat 359
x=-643.47; Shkruaj.open("D:/Libra/Koha.txt",ios::out |ios::app); Shkruaj << k << ' ' << x; cout << "\nShkruarja e dyt prfundoi" << "\n\n"; return 0; }
Pr dallim nga shembulli i programit file14, ktu gjat hapjes s dyt t fajllit sht shfrytzuar komanda ku paraqitet edhe modi i hapjes ios::app, me t cilin nnkuptohet shtimi i t dhnave q shkruhen n fajll pa i fshir ato ekzistueset. Si rezultat, prmbajtja e fajllit Koha.txt, pas ekzekutimit t programit t dhn, do t duket ashtu si sht dhn n Fig.7.23.
Fig.7.23 Prmbajtja e fajllit Koha.txt pas ekzekutimit t programit file15 Ktu, me qllim t kalimit n rreshtin vijues, n fund t shkruarjes s vlerave t para sht shfrytzuar komanda endl.
Hapja e fajllave n modin binar

N prgjithsi, prve n modin tekstual, i cili sht modi i nnkuptuar, fajllat mund t hapen edhe n modin binar, duke e shfrytzuar opcionin ios::binary. Kur fajllat hapen n modin binar, t dhnat kompjuteri i sheh si vargje bajtsh, pa i interpretuar simbolet q prfshihen brenda tyre. Kshtu, p.sh., karakteri q shfrytzohet pr t urdhruar kalimin n rresht t ri nuk shihet si komand, por vetm si nj simbol i zakonshm. Pr kt arsye, shkruarja dhe leximi te fajllat e hapur si binar sht m e shpejt, krahasuar me fajllat tekstual. Shembull Programi file16, prmes s cilit n fajllin Koha.bin shkruhen 3 rreshta, duke e hapur fajllin n modin binar.
// Programi file16 #include <iostream> #include <fstream>

using namespace std; int main() { int i; ofstream Shkruaj("D:/Libra/Koha.bin",ios::out |ios::binary); for (i=1;i<=3;i++) Shkruaj << " Rreshti i " << i << endl; cout << "\nShkruarja n fajll prfundoi" << "\n\n"; return 0; }
Nse pas ekzekutimit t programit t dhn hapet fajlli Koha.bin, prmbajtja e tij do t duket ashtu si sht dhn n Fig.7.24. Fig.7.24 Prmbajtja e fajllit Koha.bin pas ekzekutimit t programit file16 Prej ktu shihet se manipulatori endl n fajll sht shkruar si nj simbol i cili nga kompjuteri nuk interpretohet si komand pr kalim n rresht t ri. N program, prapashtesa e fajllit sht marr si .bin, gj q praktikohet kur kemi t bjm me fajlla binar. Por, lirisht mund t zgjedhen edhe prapashtesa t tjera, prfshir edhe prapashtesn .txt. Nse gjat hapjes s fajllit nuk shnohet modi ios::binary, ai hapet si fajll tekstual, meq ky mod sht i nnkuptuar.
Pozita n fajll
Pozita n t ciln shkruhen t dhnat n fajll, ose pozita nga e cila lexohen t dhnat nga fajlli, prcaktohet me pozitn e pointerit n fajll (ang. file-position pointer). Sa her q shkruhet n fajll, ose lexohet nga fajlli, pointeri i pozits n fajll rritet automatikisht. Pozita e pointerit n fajll mund t prcaktohet edhe direkt, duke i shfrytzuar funksionet:
seekp - te fajllat e hapur pr shkruarje (shkronja p lidhet me fjaln put ). seekg - te fajllat e hapur pr lexim (shkronja g lidhet me fjaln get ).
Fajllat 361
N versionet themelore kto dy funksione shkruhen kshtu:

r.seekp(n); r.seekg(n);
ku jan:
r - rrjedha e deklaruar si objekt i klasave pr pun me fajlla. n - numri rendor i bajtit n fajll.
Shembull
Programi file17 prmes s cilit, n variabln z, nga fajlli Koha.txt lexohet prmbajtja e bajtit me numr rendor k, nse vlera e variabls k kompjuterit i jepet prmes tastiers.
// Programi file17 #include <iostream> #include <fstream> using namespace std; int main() { int k; char z; fstream Gama("D:/Libra/Koha.txt",ios::out |ios::in |ios::trunc); Gama << "Progr amimi n C++" << endl; cout << "\nPozita e simbolit q lexohet: "; cin >> k;
Gama.seekg(k); Gama.get(z); cout << << << << << return 0; } "\nKarakteri n bajtin me numr rendor " k " sht: " z "\n\n";
362 Programimi i orientuar n objekte Nse n fajll jan shkruar m-bajt, numrat rendor t tyre jan: 0, 1, 2, ..., m-1. N programin e dhn, pozita e pointerit n fajll sht prcaktuar prmes komands:
Gama.seekg(k);
Pas ksaj, duke e shfrytzuar komandn:

Gama.get(z);
nga fajlli lexohet prmbajtja e bajtit ku sht pozicionuar pointeri. Kshtu, p.sh., nse prmes tastiers, pr variabln k kompjuterit i jepet vlera 5, rezultati n ekran do t duket ashtu si sht dhn n Fig.7.25.
Fig.7.25 Pamja e ekranit pas ekzekutimit t versionit t programit file17 Funksionet seekp dhe seekg mund t shfrytzohen edhe pr pozicionimin e pointerit n fajll gjat shkruarjes ose leximit prej pozits s caktuar brenda tij. Shembull Programi file18, prmes s cilit fjalia e shkruar n fajllin Koha.txt lexohet dhe shtypet n ekran prej bajtit me numrin rendor k, nse vlera e variabls k kompjuterit i jepet si vler hyrse prmes tastiers.
// Programi file18 #include <iostream> #include <fstream> using namespace std; int main() { int k; char z; fstream Gama("D:/Libra/Koha.txt",ios::out |ios::in |ios::trunc);
Fajllat 363
Gama << "Programimi i orientuar n objekte" << endl; cout << "\nPozita prej ku lexohet: "; cin >> k; Gama.seekg(k); cout << "\nFjalia e lexuar nga fajlli:\n\n"; while (!Gama.eof()) { Gama.get(z); if (!Gama.eof()) cout << z; } cout << "\nLeximi nga fajlli prfundoi" << "\n\n"; return 0; }
N program, pasi kompjuterit t'i jepet vlera hyrse pr variabln k, prmes komands:
Gama.seekg(k);
pointeri i pozits n fajll pozicionohet n bajtin me numr rendor k. Pastaj, duke e shfrytzuar unazn while, lexohet dhe shtypet n ekran pjesa e fjalis, duke filluar nga bajti n fjal, ashtu si shihet n Fig.7.26.
Fig.7.26 Pamja e ekranit pas ekzekutimit t versionit t programit file18
Leximi i pozits aktuale n fajll

Pr leximin e numrit rendor t bajtit t pozits t pointerit n fajll shfrytzohen funksionet:

tellp - te fajllat e hapur pr shkruarje. tellg - te fajllat e hapur pr lexim.
N form t prgjithshme, funksionet n fjal shkruhen:

n=r.tellp(); n=r.tellg();
ku jan:
r - rrjedha e deklaruar si objekt i klasave pr pun me fajlla. n - pozita aktuale e pointerit t fajllit.
Shembull
Versioni file18a i programit file18, prmes s cilit para shkronjave t pjess s fjalis q lexohet prej fajllit Koha.txt shtypen edhe numrat rendor n t bajtve prkats.
// Programi file18a #include <iostream> #include <iomanip> #include <fstream> using namespace std; int main() { int k,n; char z; fstream Gama("D:/Libra/Koha.txt",ios::out |ios::in |ios::trunc); Gama << "Programimi i orientuar n objekte" << endl; cout << "\nPozita ku fillon leximi: "; cin >> k; Gama.seekg(k); cout << "\n Pozita Shkronja\n\n"; while (!Gama.eof()) { n=Gama.tellg(); Gama.get(z); if (!Gama.eof()) cout << setw(5) << n << setw(8)
Fajllat 365
<< z << endl; } cout << "Leximi nga fajlli prfundoi" << "\n\n"; return 0; }
Ktu, brenda unazs n t ciln lexohen nga fajlli dhe shtypen n ekran shkronjat e fjalis, prmes komands:
n=Gama.tellg();
lexohen dhe shtypen edhe numrat rendor (pozitat) t bajtve prkats, ashtu si shihet n Fig.7.27.

file18a
Qasja dhe lvizja e lir brenda fajllave

Funksionet seekp, seekg, tellp dhe tellg mund t shfrytzohen pr qasje dhe lvizje t lir brenda fajllave. Shembull Programi file19, prmes s cilit gjenden pozitat e shkronjs s caktuar x brenda fjalis s shkruar n fajllin Koha.txt, nse shkronja x kompjuterit i jepet si vler hyrse prmes tastiers.
// Programi file19 #include <iostream> #include <fstream> #include <iomanip> using namespace std;

int main() { int m; char x,z; fstream Gama("D:/Libra/Koha.txt",ios::out |ios::in |ios::trunc); Gama << "Programimi i orientuar n objekte" << endl; cout << "\nShkronja q krkohet: "; cin >> x; Gama.seekg(0); cout << "\nPozitat e shkronjs " << x << "\n\n"; while (!Gama.eof()) { m=Gama.tellg(); Gama.get(z); if (!Gama.eof() && z==x) cout << setw(8) << m << endl; } cout << "\nLeximi nga fajlli prfundoi" << "\n\n"; return 0; } Nse, p.sh., prmes tastiers pr variabln x e cila lexohet, kompjuterit i jepet shkronja i, rezultati n ekran do t duket ashtu si sht dhn n Fig.7.28.
Fig.7.28 Pamja e ekranit pas ekzekutimit t versionit t programit file19
Fajllat 367
Qasja relative n fajll

Funksionet seekp dhe seekg mund t shkruhen edhe duke ua shtuar brenda kllapave parametrin e dyt, prmes s cilit prcaktohet drejtimi i qasjes (ang. seek direction), n kt mnyr:
r.seekg(n,d); r.seekp(n,d);
ku jan:
r - rrjedha e deklaruar si objekt i klasave pr pun me fajlla. n - numri i bajtve pr sa zhvendoset pointeri n drejtimin e zgjedhur. d - drejtimi n t cilin zhvendoset pointeri.
Pr parametrin d mund t zgjedhet njri nga tri opcionet:

ios::beg - zhvendosje prej fillimit t fajllit kah fundi i tij. ios::end - zhvendosje prej fundit t fajllit kah fillimi i tij. ios::cur - zhvendosje prej pozits aktuale kah fundi i fajllit.
Kto forma t shkruarjes s funksioneve seekg dhe seekp n fakt shfrytzohen pr zhvendosje t pointerit n fajll prej pozits aktuale, pr n-bajt n drejtimin e zgjedhur. Shembull Programi file20, prmes s cilit gjendet madhsia n bajt e fajllit Koha.txt, duke i shfrytzuar funksionet seekg dhe tellg.
// Programi file20 #include <iostream> #include <fstream> using namespace std; int main() { int m; ofstream Alfa("D:/Libra/Koha.txt",ios::out); Alfa << "Programimi i orientuar n objekte" << endl; cout << "\nShkruarja n fajll prfundoi" << "\n"; Alfa.close(); ifstream Beta("D:/Libra/Koha.txt",ios::in);
Beta.seekg(0,ios::end); m=Beta.tellg(); cout << << << << return 0; } "\nMadhsia e fajllit sht " m " bajt" "\n\n";

Beta.seekg(0,ios::end);
pointeri i pozits n fajll zhvendoset pr lexim pr 0 bajt prej fundit t tij, prkatsisht pointeri zhvendoset n fund t fajllit. Pastaj, duke e shfrytzuar komandn:
m=Gama.tellg();
lexohet vlera e pointerit t pozits n fajll, e cila vler n kt rast sht e barabart me madhsin e fajllit. Rezultati n ekran do t duket ashtu si sht dhn n Fig.7.29.
Fig.7.29 Pamja e ekranit pas ekzekutimit t versionit t programit file20 Nga pozita aktuale e pointerve n fajlla mund t lvizet pr nj numr t caktuar bajtsh, gj q kryesisht shfrytzohet gjat leximit t t dhnave prej tyre. Shembull Programi file20a, prmes s cilit nga fajllit Koha.txt, lexohet shkronja q gjendet n pozitn e fundit t tij.
// Programi file20a #include <iostream> #include <fstream> using namespace std; int main() {
Fajllat 369
int m; ofstream Alfa("D:/Libra/Koha.txt",ios::out); Alfa << "Programimi i orientuar n objekte" << endl; cout << "\nShkruarja n fajll prfundoi" << "\n"; Alfa.close(); ifstream Beta("D:/Libra/Koha.txt",ios::in); Beta.seekg(0,ios::end); m=Beta.tellg(); char a; Beta.seekg(m-3,ios::beg); Beta.get(a); cout << "\n\nN fund t fajllit gjendet shkronja " << a << "\n\n"; return 0; }
Meq numrat rendor t bajtve, prkatsisht shkronjave t veanta n fjali, shkojn prej 0 deri n 32, pr ta lexuar shkronjn e fundit e n t pointeri pozicionohet prmes komands:
Beta.seekg(m-3,ios::beg);
Gjat ekzekutimit t ksaj komande, prej pozits aktuale n fillim t fajllit, pointeri zhvendoset pr m-3=35-3=32 bajt n fund t tij. Shembull Programi file21, tek i cili gjat leximit nga fajlli Koha.txt, tregohet rritja e pointerit t pozits n fajll pr nga 3 bajt, duke e shfrytzuar funksionin seekg.
// Programi file21 #include <iostream> #include <fstream> #include <iomanip> using namespace std; int main() { char z; fstream Gama("D:/Libra/Koha.txt",ios::out

|ios::in |ios::trunc); Gama << "Programimi i orientuar n objekte" << endl; Gama.seekg(0); cout << "\nShkronjat e lexuara nga fajlli:\n\n"; while (!Gama.eof()) { Gama.seekg(2,ios::cur); Gama.get(z); if(!Gama.eof()) cout << setw(5) << Gama.tellg() << setw(5) << z << endl; } cout << "\nLeximi nga fajlli prfundoi" << "\n\n"; return 0; }
Ktu, prmes komands:

Gama.seekg(2,ios::cur);
urdhrohet q pointeri i pozits n fajll t rritet pr 2 bajt nga pozita aktuale e tij (drejtimi i lvizjes prcaktohet me ios::cur). Por, meq gjat leximit nga fajlli, pas do bajti t lexuar, vlera e pointerit rritet automatikisht pr 1, n shembullin e programit t dhn ai do t rritet pr 3 bajt. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket ashtu si shihet n Fig.7.30.
Fajllat 371 Fig.7.30 Pamja e ekranit pas ekzekutimit t programit file21
Nse n programin file21 funksioni seekg shkruhet:

Gama.seekg(0,ios::cur);
nga fajlli Koha.txt do t lexohet komplet fjalia, sepse me t urdhrohet zhvendosja e pointerit pr 0 bajt, prkatsisht mbetet vetm rritja e tij automatike pr 1 bajt pas do leximi. Pozita e pointerit n fajll mund t prcaktohet edhe duke u zhvendosur prej fillimit t tij pr nj numr t caktuar bajtsh. Shembull Programi file22, prmes s cilit nga fajlli Koha.txt lexohet do i katrti bajt, duke u zhvendosur prej fillimit t tij pr k bajt prmes funksionit seekg.
// Programi file22 #include <iostream> #include <fstream> using namespace std; int main() { int k,m; char z; fstream Gama("D:/Libra/Koha.txt",ios::out |ios::in |ios::trunc); Gama << "Programimi i orientuar n objekte" << endl; cout << "\nShkronjat e lexuara nga fajlli:\n\n"; Gama.seekg(0,ios::end); m=Gama.tellg(); k=0; while (k<=m) { Gama.seekg(k,ios::beg);

Gama.get(z); cout << z << "..."; k=k+4; } cout << "\n\nLeximi nga fajlli prfundoi" << "\n\n"; return 0; }

Gama.seekg(k,ios::beg);
pointeri i pozicionit n fajll vendoset direkt n bajtin me numr rendor k. Por, meq variabla k rritet pr 4, ajo mund t marr vlera, t cilat i tejkalojn numrat rendor t bajtve n fajll. Pr kt qllim, prsritja e unazs while sht kufizuar me kushtin k<=m, ku m e paraqet madhsin e fajllit n bajt. Nse ekzekutohet programi i dhn, rezultati q shtypet n ekran do t duket ashtu si sht dhn n Fig.7.31, ku me tri pikat e shtypura tregohen shkronjat e palexuara t fjalis, me prjashtim t atyre n fund t fjalis.
Fig.7.31 Pamja e ekranit pas ekzekutimit t programit file22
Fajllat me qasje direkte

Pr qasje direkte te t dhnat e prfshira n fajlla, si dhe pr azhurimin e tyre, shfrytzohen fajlla me qasje direkte (ang. random-access files). N praktik, fajllat e till deklarohen si fajlla binar dhe formohen duke shfrytzuar regjistrime me gjatsi fikse. N kt mnyr, pr shkak t gjatsis fikse, direkt mund t gjenden adresat e regjistrimeve t veanta brenda fajllave, prkatsisht numrat rendor t bajtve brenda tyre. Te fajllat me qasje direkte, t dhnat shkruhen ose lexohen si blloqe t dhnash, duke i shfrytzuar funksionet write dhe read. Gjat ksaj, hapsira
Fajllat 373 memoruese, e cila shfrytzohet n fajll pr ruajtjen e t dhnave t veanta, sht fikse dhe varet nga tipi i variablave prkatse. Kshtu, p.sh., pr ruajtjen e vlers 32458372 t nj variable t tipit int, n fajll do t shfrytzohet hapsir 4bajtshe, gj q dallon nga fajllat me qasje sekuenciale, te t cilt numri i njjt vendoset n 8-bajt (pr do shifr shfrytzohet 1 bajt).
Shkruarja n fajlla
Funksioni write pr shkruarje n fajlla, n formn e tij bazike, duket:
r.write((char*) &v,sizeof(v));
ku jan:
r - rrjedha e deklaruar si objekt i klasave pr pun me fajlla. &v - adresa e variabls v, vlera e s cils shkruhet n fajll. sizeof(v) - numri i bajtve te t cilt shkruhet vlera e variabls v.
Prmes funksionit write, vlera e variabls v shkruhet n hapsirn e fajllit e cila ka madhsi prej sizeof(v) bajt. Gjat ksaj, para shkruarjes n fajll, adresa e variabls &v konvertohet n pointerin e tipit karakter (char*). Shembull Programi fileD1, prmes s cilit vlera e variabls a shkruhet n fajllin me qasje direkte Delta.bin.
// Programi fileD1 #include <iostream> #include <fstream> using namespace std; int main() { int a; a=348576312; ofstream Alfa ("C:/Delta.bin",ios::out|ios::binary); Alfa.write((char*) &a,sizeof(a)); cout << "\nShkruarja n fajll prfundoi" << "\n\n"; return 0; }
Nse kontrollohet fajlli Delta.bin, pas shkruarjes s vlers n t do t shihet se madhsia e tij sht 4 bajt, sepse variabla k, vlera e s cils vendoset
374 Programimi i orientuar n objekte n fajll, sht e tipit int. Meq vlera n fajll nuk regjistrohet si tekst, hapja e tij prmes ndonj tekstprocesori sht e pamundur, ose, edhe nse hapet, n t nuk do t shihet vlera e regjistruar. Para shkruarjes s vlers n fajll, kompjuteri at e paketon n nj format t veant, ashtu q edhe pse numri ka 9 shifra ai t regjistrohet n 4 bajt (numri i njjt n nj fajll tekstual regjistrohet n 9 bajt). Pr shkruarje n fajll mund t shfrytzohet edhe versioni vijues i funksionit write:
r.write((const char*) &v,sizeof(v));
Gjat ksaj, para shkruarjes n fajll, adresa e variabls &v konvertohet n pointer si konstante e tipit karakter (const char*).
Leximi nga fajllat

Pr leximin e t dhnave t shkruara n fajlla me qasje direkte shfrytzohet funksioni read, i cili n form t prgjithshme shkruhet:
r.read((char*) &v,sizeof(v));
ku jan:
r - rrjedha e deklaruar si objekt i klasave pr pun me fajlla. &v - adresa e variabls v, vlera e s cils lexohet nga fajlli. sizeof(v) - numri i bajtve nga t cilt lexohet vlera e variabls v.
Prmes funksionit read, vlera e variabls v lexohet nga hapsira e fajllit, e cila ka madhsi prej sizeof(v) bajtsh, me ndrmjetsimin e pointerit t tipit karakter char*. Shembull Programi fileD2, prmes s cilit te variabla b lexohet vlera e cila sht shkruar n fajllin me qasje direkte Delta.bin prmes programit fileD1.
// Programi fileD2 #include <iostream> #include <fstream> using namespace std; int main() { int b; ifstream Beta("C:/Delta.bin",ios::in|ios::binary); Beta.read((char*) &b,sizeof(b));
Fajllat 375
cout << "\nVlera e lexuar nga fajlli b=" << b << "\n\n"; return 0; }
Ktu, pr leximin e vlers nga fajlli sht shfrytzuar variabla b, e tipit t njjt me variabln a, e cila sht shfrytzuar te programi fileD1 gjat shkruarjes s saj n fajll. Variabla a mund t merret edhe gjat leximit, pa qen nevoja q t dallohet variabla q shfrytzohet gjat shkruarjes nga ajo q shfrytzohet gjat leximit. Nse ekzekutohet programi i dhn, rezultati n ekran do t duket si n Fig.7.32. Fig.7.32 Pamja e ekranit pas ekzekutimit t programit
fileD2
Gjat shkruarjes n fajll dhe leximit prej tij, funksioni sizeof, i shfrytzuar te dy programet e msiprme, mund t shkruhet edhe duke e shnuar vetm tipin t t variabls v, si sizeof(t). Por, kto dy forma t funksionit n fjal mund t shkruhen edhe pa i shfrytzuar kllapat:
sizeof v sizeof t
Shembull
Programi fileD3, prmes s cilit te fajlli me qasje direkte Delta.bin s pari shkruhet vlera e variabls z, e cila sht deklaruar si variabl e tipit double dhe pastaj vlera e njjt edhe lexohet.
// Programi fileD3 #include <iostream> #include <fstream> using namespace std; int main() { double z; z=-543719.8532;

ofstream Alfa ("C:/Delta.bin",ios::out|ios::binary); Alfa.write((char*) &z,sizeof(double)); cout << "\nShkruarja n fajll prfundoi" << "\n"; Alfa.close(); ifstream Beta("C:/Delta.bin",ios::in|ios::binary); Beta.read((char*) &z,sizeof(double)); cout << << << << return 0; } fixed "\nVlera e lexuar nga fajlli z=" z "\n\n";
N kt rast, vlera e variabls z shkruhet n 8 bajt t fajllit, aq sa nevojiten pr vlerat e tipit double. Gjat ksaj, numri i bajtve n t cilt shkruhet dhe pastaj lexohet vlera n fjal prcaktohet prmes funksionit sizeof(double) . Rezultati q shtypet n ekran pas ekzekutimit t programit t dhn do t duket ashtu si sht dhn n Fig.7.33. Fig.7.33 Pamja e ekranit pas ekzekutimit t programit fileD3
Vlerat e disa variablave n fajlla

Te fajllat me qasje direkte zakonisht shkruhen m shum t dhna, duke shfrytzuar edhe variabla t tipeve t ndryshme. Gjat ksaj, pr shkruarjen ose edhe leximin e secils prej tyre shfrytzohen komanda t veanta write dhe read. Shembull Programi fileD4, prmes s cilit te fajlli me qasje direkte Delta.bin s pari shkruhen dhe pastaj lexohen vlerat e variablave a e z, njra e tipit int dhe tjetra e tipit double.
// Programi fileD4 #include <iostream>
Fajllat 377
#include <fstream> using namespace std; int main() { int a; double z; a=348576312; z=-543719.8532; ofstream Alfa ("C:/Delta.bin",ios::out|ios::binary); Alfa.write((char*) &a,sizeof(a)); Alfa.write((char*) &z,sizeof(z)); cout << "\nShkruarja n fajll prfundoi" << "\n"; Alfa.close(); ifstream Beta("C:/Delta.bin",ios::in|ios::binary); Beta.read((char*) &a,sizeof(a)); Beta.read((char*) &z,sizeof(z)); cout << fixed << "\nVlerat e lexuara nga fajlli:" << "\n\na=" << a << "\n\nz=" << z << "\n\n"; return 0; }
Pas ekzekutimit t programit t dhn, rezultati q shtypet n ekran do t duket ashtu si sht dhn n Fig.7.34.

fileD4
Ngjashm veprohet edhe nse n fajlla me qasje direkte shkruhen ose lexohen vlerat e m shum variablave.
Vlerat e fushave n fajlla

N fajllat me qasje direkte mund t shkruhen vlerat e fushave njdimensionale (vektorve), fushave dydimensionale (matricave), ose edhe t atyre shumdimensionale.
Vlerat e vektorve
Komandat pr shkruarje t vektorve n fajlla me qasje direkte dhe me leximin e tyre prej fajllave nuk dallojn nga ato t shfrytzuara gjat shkruarjes dhe leximit t vlerave t variablave t zakonshme. Shembull Programi fileD5, prmes s cilit tregohet shkruarja e vektorit A(n) te fajlli me qasje direkte Delta.bin, pastaj leximi i tij nga fajlli dhe shtypja n ekran.
// Programi fileD5 #include <iostream> #include <fstream> using namespace std; int main() { int const n=6; int i,A[n]={7,3,9,2,4,1}; // ------ Shkruarja n fajll e vektorit ---------------ofstream Alfa ("C:/Delta.bin",ios::out|ios::binary); Alfa.write((char*) &A,sizeof(A)); cout << "\nShkruarja n fajll prfundoi" << "\n"; Alfa.close(); // --- Shoqrimi i vlerave zero antarve t vektorit -for (i=0;i<n;i++) A[i]=0; // ------ Leximi i vektorit nga fajlli ----------------ifstream Beta("C:/Delta.bin",ios::in|ios::binary);
Fajllat 379
Beta.read((char*) &A,sizeof(A)); // ------ Shtypja e vektorit n ekran -----------------cout << "\nVlerat e lexuara nga fajlli:\n"; for (i=0;i<n;i++) cout << "\n A[" << i << "]=" << A[i]; cout << "\n\n"; return 0; }
N program, me qllim q t shihet se vlerat e antarve t vektorit lexohen prej fajllit, para se t lexohen atyre u shoqrohen vlera zero. N pjesn e fundit t programit, vlerat e lexuara nga fajlli shtypen n ekran, ashtu si sht dhn n Fig.7.35.
Fig.7.35 Pamja e ekranit pas ekzekutimit t programit fileD5 Madhsia e hapsirs memoruese q shfrytzohet nga fajlli Delta.bin, n t cilin shkruhen vlerat e antarve t vektorit A(n), do t jet 24 bajt, sepse vektori ka 6 antar t tipit int, me madhsi 4 bajt secili. N programin e msiprm, komandat pr shkruarje n fajll dhe leximit prej tij mund t shkruhen edhe n format:
Alfa.write((char*) &A,n*sizeof(int)); Beta.read((char*) &A,n*sizeof(int));
N fakt, ktu hapsira n t ciln shkruhet vektori n fajll, ose lexohet prej tij, prcaktohet duke e shumzuar numrin e antarve t vektorit n dhe numrin e bajtve q shfrytzohen prej tyre sizeof(int). Vektori mund t shkruhet edhe duke i shkruar antart nj nga nj, prmes nj unaze. Shembull Versioni fileD6 i programit fileD5, prmes s cilit tregohet shkruarja nj nga nj e antarve t vektorit A(n) te fajlli me qasje direkte Delta.bin.
Nga programi fileD5, versioni fileD6 i tij do t dallohet vetm n pjesn pr shkruarje n fajll, e cila do t duket:
................................................. ofstream Alfa ("C:/Delta.bin",ios::out|ios::binary); for (i=0;i<n;i++) Alfa.write((char*) &A[i],sizeof(A[i])); .................................................
Edhe leximi i antarve t vektorit mund t realizohet, duke i lexuar nj nga nj antart e tij nga fajlli. Shembull Versioni fileD7 i programit fileD5, prmes s cilit tregohet leximi nj nga nj i antarve t vektorit A(n) nga fajlli me qasje direkte Delta.bin.
Nga programi fileD5, versioni fileD7 i tij do t dallohet vetm n pjesn pr lexim nga fajlli dhe shtypje n ekran, e cila do t duket:
............................................ cout << "\nVlerat e lexuara nga fajlli:\n"; for (i=0;i<n;i++) { Beta.read((char*) &A[i],sizeof(A[i])); cout << "\n A[" << i << "]=" << A[i]; } cout << "\n\n"; return 0; }
Ktu, pr lexim mund t shfrytzohet nj variabl ndihmse, e cila sht fush, ose edhe variabl e zakonshme e tipit t njjt. Kshtu, p.sh., nse pr lexim shfrytzohet variabla e zakonshme b, pjesa e fundit e programit do t duket si n vijim.
............................................ cout << "\nVlerat e lexuara nga fajlli:\n"; int b; for (i=0;i<n;i++) {
Fajllat 381
Beta.read((char*) &b,sizeof(b)); cout << "\n A[" << i << "]=" << b; } cout << "\n\n"; return 0; }
N kt rast, vlerat q lexohen ruhen prkohsisht te variabla ndihmse b.
Vlerat e matricave
N fajllat me qasje direkte mund t shkruhen dhe t lexohen t dhnat e prfshira n matrica, plotsisht njlloj si shkruhen dhe lexohen vektort. Shembull Programi fileD8, prmes s cilit tregohet shkruarja n fajllin Delta.bin e vlerave t matrics A(m,n) dhe pastaj edhe leximi i tyre prej fajllit.
// Programi fileD8 #include <iostream> #include <fstream> #include <iomanip> using namespace std; int main() { int const m=4,n=5; int A[m][n]={{12,4,7,-2,24}, {3,-8,25,64,1}, {28,69,85,33,6}, {-9,18,2,5,-17}}; int i,j; // ------ Shkruarja n fajll e matrics ---------------ofstream Alfa ("C:/Delta.bin",ios::out|ios::binary); Alfa.write((char*) &A,sizeof(A)); cout << "\nShkruarja n fajll prfundoi" << "\n"; Alfa.close(); // --- Shoqrimi i vlerave zero antarve t matrics --

for (i=0;i<m;i++) for (j=0;j<n;j++) A[i][j]=0; // ------ Leximi i matrics nga fajlli ----------------ifstream Beta("C:/Delta.bin",ios::in|ios::binary); Beta.read((char*) &A,sizeof(A)); // ------ Shtypja e matrics n ekran -----------------cout << "\nMatrica e lexuar nga fajlli:\n\n"; for (i=0;i<m;i++) { for (j=0;j<n;j++) cout << setw(5) << A[i][j]; cout << endl; } cout << "\n"; return 0; }
Nse ekzekutohet programi i dhn, rezultati n ekran do t duket ashtu si shihet n Fig.7.36.

fileD8
Antart e matricave n fajll mund t shkruhen ose t lexohen edhe nj nga nj, ashtu si u tregua n pjesn paraprake pr vektort. Gjithashtu, gjat leximit t antarve t matricave mund t shfrytzohen variabla ndihmse t zakonshme, ose edhe fusha t tjera. Gjat shkruarjes n fajlla dhe leximit prej tyre, plotsisht njlloj mund t veprohet edhe nse kemi t bjm me fusha shumdimensionale, si u tregua m sipr pr vektort dhe matricat.
Vlerat e llogaritura n fajlla

N fajllat me qasje direkte mund t shkruhen edhe vlerat q llogariten brenda programit.
Fajllat 383
Shembull
Programi fileL, prmes s cilit tregohet shkruarja n fajllin me qasje direkte Drejt.bin t vlerave t brinjve a e b t drejtkndshit, si dhe siprfaqes s dhe perimetrit p prkats t tij. Vlera e brinjs b merret fikse, kurse vlerat e brinjs a ndryshohen me hapin 0.5, mes vlerave 1 dhe 5. N fund, vlerat e shkruara lexohen nga fajlli dhe shtypen n ekran.
// Programi fileL #include <iostream> #include <fstream> #include <iomanip> using namespace std; int main() { double a,b,s,p; ofstream Alfa ("C:/Drejt.bin",ios::out|ios::binary); // --- Llogaritja dhe shkruarja n fajll -------------b=6; for(a=1;a<=5;a=a+0.5) { s=a*b; p=2*(a+b); Alfa.write((char*) Alfa.write((char*) Alfa.write((char*) Alfa.write((char*) } cout << "\nShkruarja n fajll prfundoi" << "\n\n"; Alfa.close(); // --- Leximi nga fajlli dhe shtypja n ekran -------ifstream Beta("C:/Drejt.bin",ios::in|ios::binary); cout << "T dhnat e lexuara nga fajlli\n\n" << " a b s p\n\n"; while(!Beta.eof()) { &a,sizeof(a)); &b,sizeof(b)); &s,sizeof(s)); &p,sizeof(p));

Beta.read((char*) Beta.read((char*) Beta.read((char*) Beta.read((char*) &a,sizeof(a)); &b,sizeof(b)); &s,sizeof(s)); &p,sizeof(p));
if (!Beta.eof()) cout << fixed << setprecision(2) << setw(6) << a << setw(6) << b << setw(8) << s << setw(8) << p << endl; } cout << endl; return 0; }
Prmes unazs for n fillim t programit shkruhen n fajll vlerat e brinjve t drejtkndshit si dhe vlerat prkatse t llogaritura t siprfaqes s dhe t perimetrit p. Pastaj, pas mbylljes, fajlli rihapet dhe nga ai lexohen vlerat dhe shtypen n ekran ashtu si shihet n Fig.7.37.
Fig.7.37 Pamja e ekranit pas ekzekutimit t programit fileL
Tekstet n fajlla
Te fajllat me qasje direkte mund t shkruhen edhe tekste, plotsisht njlloj si shkruhen vlerat numerike. Por, gjat ksaj, pr do simbol t prfshir n
Fajllat 385 tekst kompjuteri shfrytzon nj bajt dhe tekstet shkruhen si edhe te fajllat me qasje sekuenciale. Shembull Programi fileT1, prmes s cilit tregohet shkruarja n fajllin me qasje direkte Omega.txt e tekstit T. Pastaj, pr t'u shtypur n ekran, teksti lexohet nga fajlli te vektori G.
// Programi fileT1 #include <iostream> #include <fstream> using namespace std; int main() { char T[]=" Koha e bukur",G[15]; ofstream Alfa("C:/Omega.txt",ios::out|ios::binary); Alfa.write((char *) &T,sizeof(T)); cout << "\nShkruarja n fajll prfundoi" << "\n\n"; Alfa.close(); cout << "Teksti i lexuar nga fajlli\n\n"; ifstream Beta("C:/Omega.txt",ios::in|ios::binary); Beta.read((char *) &G,sizeof(T)); Beta.close(); cout << G << "\n\n"; return 0; }
Nse pas ekzekutimit t programit, hapet fajlli Omega.txt prmes programit Microsoft Notepad, prmbajtja e tij do t shihet direkt, ashtu si sht dhn n Fig.7.38. Fig.7.38 Prmbajtja e fajllit Omega.txt pas ekzekutimit t programit fileT1
386 Programimi i orientuar n objekte Nse ekzekutohet programi i dhn, rezultati q shtypet n ekran do t duket ashtu si shihet n Fig.7.39.

fileT1
Tekstet dhe vlerat numerike n fajlla

Te fajllat me qasje direkte, si edhe tek ata me qasje sekuenciale, njkohsisht mund t shkruhen tekste dhe vlera numerike. Gjat ksaj, komandat q shfrytzohen pr shkruarje nuk dallohen nga ato q u shpjeguan n pjesn paraprake. Shembull Programi fileT2, prmes s cilit tregohet shkruarja n fajllin me qasje direkte Omega.txt i tekstit T dhe vlers numerike t variabls x. Pastaj, pr t'u shtypur n ekran, teksti lexohet nga fajlli te vektori G, kurse vlera numerike lexohet me ndrmjetsimin e variabls x.
// Programi fileT2 #include <iostream> #include <fstream> using namespace std; int main() { double x=768352.3489; char T[]=" Koha e bukur",G[15]; ofstream Alfa("C:/Omega.txt",ios::out|ios::binary); Alfa.write((char *) &x,sizeof(x)); Alfa.write((char *) &T,sizeof(T)); cout << "\nShkruarja n fajll prfundoi" << "\n\n"; Alfa.close(); cout << "T dhnat e lexuara nga fajlli\n\n"; ifstream Beta("C:/Omega.txt",ios::in|ios::binary);
Fajllat 387
Beta.read((char *) &x,sizeof(x)); Beta.read((char *) &G,sizeof(T)); Beta.close(); cout << "x=" << x << G << "\n\n"; return 0; }
Nse pas ekzekutimit t programimit hapet fajlli duke e shfrytzuar programin Microsoft Notepad, prmbajtja e tij do t duket ashtu si sht dhn n Fig.7.40. Fig.7.40 Prmbajtja e fajllit Omega.txt pas ekzekutimit t programit fileT2 Prej ktu shihet se vlera e variabls x, e cila sht shkruar n 8 bajtt e par t fajllit, nuk mund t lexohet direkt. Kurse, teksti i cili sht shkruar n pjesn e dyt t fajllit, ashtu si u pa edhe n shembullin e programit paraprak, sht i lexueshm direkt. Pas ekzekutimit t programit t dhn, rezultati q shtypet n ekran do t duket ashtu si sht dhn n Fig.7.41.
Fig.7.41 Pamja e ekranit pas ekzekutimit t programit fileT2
Qasja direkte n t dhnat e fajllave

Meq te fajllat me qasje direkte regjistrimet e veanta kan gjatsi fikse, prkatsisht t dhnat shkruhen n nj numr fiks bajtsh, atyre mund t'u qasemi direkt. Gjat ksaj, duhet t llogaritet numri rendor i bajtit, ku fillon regjistrimi i t dhns t cils duhet t'i qasemi. Pastaj, duke i shfrytzuar funksionet prkatse, pointeri i pozits n fajll vendoset aty ku fillon leximi. Shembull Programi fileQ1, prmes s cilit tregohet leximi i antarit t
388 Programimi i orientuar n objekte caktuar t vektorit A(n) nga fajlli me qasje direkte Delta.bin.
// Programi fileQ1 #include <iostream> #include <fstream> using namespace std; int main() { int const n=6; int A[n]={7,3,9,2,14,1}; int k,x; // --- Shkruarja n fajll -----------------------------ofstream Alfa ("C:/Delta.bin",ios::out|ios::binary); Alfa.write((char*) &A,sizeof(A)); cout << "\nShkruarja n fajll prfundoi" << "\n"; Alfa.close(); ifstream Beta("C:/Delta.bin",ios::in|ios::binary); // --- Pozicionimi te bajti ku fillon leximi ----cout << "\nNumri i antarit q lexohet, mes 0 dhe " << n-1 << ": "; cin >> k; Beta.seekg(k*sizeof(int),ios::beg); cout << "\nVlera q duhet lexuar fillon te bajti i " << Beta.tellg() ; Beta.read((char*) &x,sizeof(int)); cout << "\n\nNga fajlli u lexua vlera " << x << "\n\n"; return 0; }
Ktu, fillimisht vlerat e antarve t vektorit A(n) shkruhen n fajll. Pastaj, prmes funksionit Beta.seekg pointeri i pozits n fajll pozicionohet te bajti me numr rendor k*sizeof(int), ku k sht numri rendor (indeksi) i antarit t vektorit, vlera e t cilit lexohet nga fajlli. Kjo, do t thot se pr k=3,
Fajllat 389 pointeri n fjal do t pozicionohet te bajti i 12-t, meq prej tij fillon shkruarja n fajll e vlers s antarit t 3-t. Prmes funksionit Beta.tellg merret numri rendor i bajtit ku lexohet vlera dhe i njjti shtypet n ekran. N fund, prmes komands pr lexim, vlera e zgjedhur lexohet te variabla x dhe shtypet n ekran. Nse ekzekutohet programi i dhn, pr vlern hyrse 3 t variabls k, rezultati do t duket ashtu si sht dhn n Fig.7.42.
Fig.7.42 Pamja e ekranit pas ekzekutimit t programit fileQ1
Shfrytzimi i t dhnave nga fajllat

Gjat llogaritjeve t ndryshme, mund t shfrytzohen edhe t dhnat q ruhen n fajlla me qasje direkte. Shembull Programi fileQ2, prmes s cilit tregohet llogaritja e shums s t antarve me indeks ift t vektorit A(n), t cilt fillimisht shkruhen n fajllin Delta.bin dhe pastaj, prmes qasjes direkte, lexohen nga fajlli dhe i shtohen shums.
// Programi fileQ2 #include <iostream> #include <fstream> #include <iomanip> using namespace std; int main() { int const n=7; int A[n]={7,3,9,2,4,1,5},i,x; unsigned int k,m; ofstream Alfa ("C:/Delta.bin",ios::out|ios::binary); Alfa.write((char*) &A,sizeof(A));

cout << "\nShkruarja n fajll prfundoi" << "\n"; Alfa.close(); ifstream Beta("C:/Delta.bin",ios::in|ios::binary); Beta.seekg(0,ios::end); m=Beta.tellg(); cout << << << << "\nMadhsia e fajllit sht " m " bajt\n" "\n i k A[i]\n\n";
double s=0; i=0; do { Beta.seekg(i*sizeof(int),ios::beg); k=Beta.tellg(); Beta.read((char*) &x,sizeof(int)); s=s+x; cout << setw(5) << i << setw(7) << k << setw(7) << x << endl; i=i+2; } while (i<n); cout << "\nShuma e llogaritur sht s=" << s << "\n\n"; return 0; }
Vlerat q shfrytzohen gjat llogaritjes s shums ktu lexohen direkt nga fajlli. Pozicionimi te bajtt n t cilt fillon vendosja e ktyre vlerave, bhet prmes funksioninit seekg, duke e shkruar at n formn:
Beta.seekg(i*sizeof(int),ios::beg);
ku me shprehjen i*sizeof(int) llogaritet numri rendor i bajtit n t cilin fillon leximi i vlers x, t antarit t i-t t vektorit. Ky numr pastaj merret prmes shprehjes:
Fajllat 391
k=Beta.tellg();
Rezultati, i cili fitohet n ekran, pas ekzekutimit t programit t dhn, do t duket si n Fig.7.43.
Fig.7.43 Pamja e ekranit pas ekzekutimit t programit fileQ2
Objektet n fajlla
T dhnat e prfshira n komponentet e objekteve t strukturave ose t klasave mund t shkruhen n fajlla me qasje sekuenciale, ose n fajlla me qasje direkte. Gjithashtu, gjat leximit t t dhnave prej fajllave ato mund t ruhen n komponentet e objekteve t strukturave ose t klasave.
Objektet te fajllat me qasje sekuenciale

Te fajllat me qasje sekuenciale, objektet shkruhen ose lexohen prej tyre, duke i shkruar ose lexuar vlerat e komponenteve prkatse, ashtu si shkruhen ose si lexohen vlerat e variablave t zakonshme. Shembull Programi fileO1, prmes s cilit tregohet shkruarja n fajllin me qasje sekuenciale Drejt.txt t objektit Dita t strukturs Drejt, n komponentetet e t cilave prfshihen brinjt a e b t drejtkndshit, si dhe siprfaqja s dhe perimetri p prkats i tij. Vlera e brinjs b merret fikse, kurse vlerat e brinjs a ndryshohen me hapin 0.5, mes vlerave 1 dhe 5.
// Programi fileO1 #include <iostream> #include <fstream> #include <iomanip> using namespace std; struct Drejt { double a,b,s,p; }; int main() { Drejt Dita; // --- Shkruarja e t dhnave n fajll -------ofstream Alfa ("C:/Drejt.txt",ios::out); Dita.b=6; for(Dita.a=1;Dita.a<=5;Dita.a=Dita.a+0.5) { Dita.s=Dita.a*Dita.b; Dita.p=2*(Dita.a+Dita.b); Alfa << fixed << setprecision(2) << setw(6) << Dita.a << setw(6) << Dita.b << setw(7) << Dita.s << setw(7) << Dita.p << endl; } cout << "\nShkruarja n fajll prfundoi" << "\n\n"; Alfa.close(); // --- Leximi i t dhnave nga fajlli ---------ifstream Beta("C:/Drejt.txt",ios::in); cout << "T dhnat e lexuara nga fajlli\n\n" << " a b s p\n\n";
Fajllat 393
while(!Beta.eof()) { Beta >> Dita.a >> Dita.b >> Dita.s >> Dita.p; if (!Beta.eof()) cout << fixed << setprecision(2) << setw(6) << Dita.a << setw(6) << Dita.b << setw(8) << Dita.s << setw(8) << Dita.p << endl; } cout << endl; return 0; }
N program, fillimisht, llogariten vlerat e siprfaqes s dhe t perimetrit p t drejtkndshit pr vlera t ndryshme t brinjs a, t cilat prfshihen n komponentet e strukturs Drejt. T njjtat shkruhen n fajllin Drejt.txt, ashtu si shkruhen vlerat e variablave t zakonshme. Nse pas ekzekutimit t programit hapet fajlli me t dhna, do ta kemi pamjen e dhn Fig.7.44.
Fig.7.44 Prmbajtja e fajllit Drejt.txt pas ekzekutimit t programit fileO1 Rezultati q shtypet n ekran pas ekzekutimit t programit do t duket ashtu si sht dhn m hert te Fig.7.37. Plotsisht njlloj mund t veprohet edhe nse n fajll shkruhen t dhnat e prfshira n komponentet me t dhna t objekteve t klasave. Shembull Versioni fileO1a i programit fileO1, tek i cili vlerat e brinjve a dhe b t drejtkndshit, si dhe siprfaqja s dhe
394 Programimi i orientuar n objekte perimetri p i tij prfshihen n klasn Drejt. N versionin fileO1a t programit fileO1, deklarimi i strukturs Drejt duhet t zvendsohet me deklarimin e klass prkatse:
class Drejt { public: double a,b,s,p; };
Pjest e tjera t programit mbeten t pandryshuara.
Objektet te fajllat me qasje direkte

Vlerat e variablave brenda objekteve t strukturave ose t klasave mund t shkruhen n fajllat me qasje direkte, ose t lexohen nga ato, prmes variablave t komponenteve me t dhna brenda tyre, ose prmes blloqeve me t dhna n t cilat prfshihen komplet komponentet n fjal.
Prmes variablave t komponenteve me t dhna

T dhnat brenda objekteve t strukturave ose t klasave mund t shkruhen n fajllat me qasje direkte, duke i shkruar ose duke i lexuar vlerat e variablave t cilat prfshihen n komponentet me t dhna t tyre. Shembull Versioni fileO2 i programit fileO1, prmes s cilit tregohet shkruarja n fajllin me qasje direkte Drejt.bin t objektit Dita t strukturs Drejt.
// Programi fileO2 #include <iostream> #include <fstream> #include <iomanip> using namespace std; void shtyp(double a,double b,double s,double p); struct Drejt { double a,b,s,p; }; int main()
Fajllat 395
{ Drejt Dita; ofstream Alfa ("C:/Drejt.bin",ios::out|ios::binary); Dita.b=6; for(Dita.a=1;Dita.a<=5;Dita.a=Dita.a+0.5) { Dita.s=Dita.a*Dita.b; Dita.p=2*(Dita.a+Dita.b); Alfa.write((char*) &(Dita.a),sizeof(Dita.a)); Alfa.write((char*) &(Dita.b),sizeof(Dita.b)); Alfa.write((char*) &(Dita.s),sizeof(Dita.s)); Alfa.write((char*) &(Dita.p),sizeof(Dita.p)); } cout << "\nShkruarja n fajll prfundoi" << "\n\n"; Alfa.close(); ifstream Beta("C:/Drejt.bin",ios::in|ios::binary); cout << "T dhnat e lexuara nga fajlli\n\n" << " a b s p\n\n"; while(!Beta.eof()) { Beta.read((char*) &(Dita.a),sizeof(Dita.a)); Beta.read((char*) &(Dita.b),sizeof(Dita.b)); Beta.read((char*) &(Dita.s),sizeof(Dita.s)); Beta.read((char*) &(Dita.p),sizeof(Dita.p)); if (!Beta.eof()) shtyp(Dita.a,Dita.b,Dita.s,Dita.p); } cout << endl; return 0; } void shtyp(double a,double b,double s,double p) { cout << fixed << setprecision(2) << setw(6) << a << setw(6) << b << setw(8) << s << setw(8) << p

<< endl; return; }
Ktu, brenda unazs s par, pas llogaritjes s vlerave t siprfaqes s dhe t perimetrit p t drejtkndshit pr kombinimet e veanta t vlerave t brinjve a dhe b, ato shkruhen n fajll duke shfrytzuar pr seciln variabl nj komand t veant write. Ngjashm veprohet n unazn e dyt, gjat leximit t t dhnave nga fajlli, duke shfrytzuar katr komanda read. Pr shtypje t vlerave t lexuara shfrytzohet funksioni shtyp, i cili sht definuar jasht strukturs si funksion i pavarur. Rezultati q shtypet n ekran pas ekzekutimit t programit t dhn do t duket ashtu si sht dhn m hert te Fig.7.37. Rezultati i leximit nga fajlli nuk ndryshon nse gjat hapjes s tij nuk shfrytzohet edhe opcioni ios::binary, prkatsisht nse pr hapje shfrytzohet komanda:
ifstream Beta("C:/Drejt.bin",ios::in);
Nse n fajll shkruhen t dhnat q prfshihen n komponentet me t dhna t objekteve t klasave, brenda programeve do t ndryshoj vetm deklarimi i klasave prkatse.
Prmes blloqeve me t dhna

N fajlla mund t shkruhen, ose prej fajllave mund t lexohen komplet pjest me t dhna t objekteve, duke i llogaritur si blloqe t dhnash. Pr kt qllim shfrytzohen funksionet write dhe read, t cilat n form t prgjithshme shkruhen:
r.write(reinterpret_cast<char*>(&o),sizeof(o)); r.read(reinterpret_cast<char*>(&o),sizeof(o));
ku jan:
r - rrjedha e deklaruar si objekt i klasave pr pun me fajlla. &o - adresa e objektit o q shkruhet n fajll. sizeof(o) - numri i bajtve n fajll, te t cilt shkruhen vlerat e prfshira n komponentet me t dhna t objektit o.
Ktu, shkruarja ose leximi i t dhnave bhet me ndrmjetsimin e pointerit t tipit karakter char*. Por, gjat ksaj, pr konvertimin e adress s objektit (&o) n pointerin e tipit karakter (char*), shfrytzohet operatori reinterpret_cast .
Fajllat 397
Shembull
Versioni fileO3 i programit fileO2, prmes s cilit tregohet shkruarja n fajllin me qasje direkte Drejt.bin t objektit Dita t strukturs Drejt, duke e llogaritur pjesn me t dhna t objektit si nj bllok me t dhna.
// Programi fileO3 #include <iostream> #include <fstream> #include <iomanip> using namespace std; void shtyp(double a,double b,double s,double p); struct Drejt { double a,b,s,p; }; int main() { Drejt Dita; ofstream Alfa ("C:/Drejt.bin",ios::out|ios::binary); Dita.b=6; for(Dita.a=1;Dita.a<=5;Dita.a=Dita.a+0.5) { Dita.s=Dita.a*Dita.b; Dita.p=2*(Dita.a+Dita.b); Alfa.write(reinterpret_cast<char*>(&Dita), sizeof(Dita)); } cout << "\nShkruarja n fajll prfundoi" << "\n\n"; Alfa.close(); ifstream Beta("C:/Drejt.bin",ios::in|ios::binary); cout << "T dhnat e lexuara nga fajlli\n\n" << " a b s p\n\n";
while(!Beta.eof()) { Beta.read(reinterpret_cast<char*>(&Dita), sizeof(Dita)); if (!Beta.eof()) shtyp(Dita.a,Dita.b,Dita.s,Dita.p); } cout << endl; return 0; }
Pas ekzekutimit t programit t dhn, rezultati n ekran do t jet i njjt me at q sht dhn n Fig.7.37. Nnprogrami shtyp, i cili shfrytzohet gjat shtypjes n ekran t t dhnave q lexohen prej fajllit, sht i njjt me at q shfrytzohet te programi fileO2. Ktu, gjat shkruarjes s t dhnave n fajll, pr do regjistrim kompjuteri shfrytzon 32 bajt, sepse brenda tyre prfshihen vlerat e 4 variablave t komponenteve t strukturs, t cilat jan t tipit double (pr shkruarjen e vlerave t secils prej tyre shfrytzohen nga 8 bajt). Shembull Pjesa e dyt e versionit fileO4 t programit fileO3, tek i cili urdhrohet shtypja e numrave rendor k t bajtve ku fillojn regjistrimet e veanta.
// Programi fileO4 ................................................... ................................................... ifstream Beta("C:/Vlerat.bin",ios::in|ios::binary); int k; cout << "T dhnat e lexuara nga fajlli\n\n" << " k a b s p\n\n"; while(!Beta.eof()) { k=Beta.tellg(); cout << setw(5) << k; Beta.read(reinterpret_cast<char*>(&Dita), sizeof(Dita)); if (!Beta.eof()) shtyp(Dita.a,Dita.b,Dita.s,Dita.p); } cout << endl;
Fajllat 399
return 0; }
Rezultati q shtypet n ekran pas ekzekutimit t programit t dhn do t duket si n Fig.7.45.
Fig.7.45 Pamja e ekranit pas ekzekutimit t programit fileO4
N kolonn e par t ksaj tabele jan shtypur numrat rendor k t bajtve ku fillojn regjistrimet e veanta. Pr shkruarje n fajll mund t shfrytzohet edhe versioni vijues i funksionit write:
r.write(reinterpret_cast<const char*>(&o),sizeof(o));
Gjat ksaj, para shkruarjes n fajll, adresa e objektit &o konvertohet n pointer si konstante e tipit karakter const char*. Nse n fajll shkruhen t dhnat q prfshihen n komponentet e objekteve t klasave, prve deklarimit t klasave, procedura e shkruarjes s t dhnave n fajlla dhe t leximit t tyre nga fajllat nuk do t ndryshoj aspak nga ajo q shfrytzohet pr objektet e strukturave.
400 Programimi i orientuar n objekte Format e dhna m sipr pr shkruarjen e t dhnave te fajllat me qasje direkte, ose pr leximin prej tyre, plotsisht njlloj mund t shfrytzohen edhe pr variabla t zakonshme, ose edhe pr fushat.
Objektet me funksione
Nse n komponentet e strukturave ose t klasave, prve variablave me t dhna paraqiten edhe funksione, gjat shkruarjes n fajll t pjesve me t dhna t objekteve prkatse, funksionet nuk shkruhen n fajlla. Prandaj, edhe n kto raste, komandat pr shkruarje n fajlla t objekteve, ose pr lexim prej tyre, nuk do t dallohen aspak nga format q jan dhn n pjesn paraprake. Shembull Versioni fileO5 i programeve t dhna m sipr, tek i cili objekti i klass Drejt, q shkruhet n fajllin Drejt.bin me qasje direkte, e prmban edhe funksionin shtyp, i cili shfrytzohet pr shtypje t rezultateve.
// Programi fileO5 #include <iostream> #include <fstream> #include <iomanip> using namespace std; class Drejt { public: double a,b,s,p; void shtyp() { cout << fixed << setprecision(2) << setw(6) << a << setw(6) << b << setw(8) << s << setw(8) << p << endl; return; } }; int main()
Fajllat 401
{ Drejt Dita; ofstream Alfa ("C:/Vlerat.bin",ios::out|ios::binary); Dita.b=6; for(Dita.a=1;Dita.a<=5;Dita.a=Dita.a+0.5) { Dita.s=Dita.a*Dita.b; Dita.p=2*(Dita.a+Dita.b); Alfa.write(reinterpret_cast<char*>(&Dita), sizeof(Dita)); } cout << "\nShkruarja n fajll prfundoi" << "\n"; Alfa.close(); ifstream Beta("C:/Vlerat.bin",ios::in|ios::binary); cout << "\nT dhnat e lexuara nga fajlli\n\n" << " a b s p\n\n"; while(!Beta.eof()) { Beta.read(reinterpret_cast<char*>(&Dita), sizeof(Dita)); if (!Beta.eof()) Dita.shtyp(); } cout << endl; return 0; }
Pas ekzekutimit t programit t dhn, rezultati n ekran do t jet i njjt me at q sht dhn m hert n Fig.7.37. N praktik, objektet q shkruhen n fajlla mund t prmbajn t dhna t tipeve t prziera. Shembull Programi fileO6, prmes s cilit tregohet shkruarja n fajllin Jeta.bin e t dhnave t prfshira n komponentet e objektit studenti t klass person, si dhe leximin nga fajlli dhe shtypjen e tyre n ekran.
// Programi fileO6 #include <iostream>

#include <fstream> #include <iomanip> using namespace std; class person { private: char emri[8],qyteti[10]; int viti; public: void lexo(); void shtyp(); }; int main() { char a; person studenti; ofstream Alfa("C:/Jeta.bin",ios::out|ios::binary); cout << "\nT dhnat nga tastiera\n"; do { studenti.lexo(); Alfa.write(reinterpret_cast<char*>(&studenti), sizeof(studenti)); cout << "Person tjetr, P-pr Po, J-pr Jo: "; cin >> a; } while(a=='P'); cout << "\nT dhnat e lexuara nga fajlli\n" << "\n Emri Qyteti Viti\n\n"; Alfa.close(); ifstream Beta("C:/Jeta.bin",ios::in|ios::binary); while(!Beta.eof()) { Beta.read(reinterpret_cast<char*>(&studenti), sizeof(studenti)); if(!Beta.eof()) studenti.shtyp(); } cout << "\n";
Fajllat 403
return 0; } void person::lexo() { cout << "\nEmri .....: "; cin >> emri; cout << "Qyteti ...: "; cin >> qyteti; cout << "Viti .....: "; cin >> viti; cout << "\n"; }
void person::shtyp() { cout << setw(8) << emri << setw(10) << qyteti << setw(7) << viti << endl; }
N program, pr leximin e t dhnave, t cilat kompjuterit i jepen prmes tastiers, shfrytzohet funksioni lexo. Procesi i leximit prsritet n unazn do, derisa pr variabln a t tipit karakter prmes tastiers kompjuterit i jepet shkronja P. Prndryshe, cilado shkronj tjetr q t shtypet, procesi i leximit t t dhnave ndrpritet. Pas ksaj, prmes unazs while lexohen t dhnat e shkruara n fajll, t cilat njkohsisht shtypen n ekran, duke e shfrytzuar funksionin shtyp. Nse ekzekutohet programi i dhn dhe kompjuterit prmes tastiers, p.sh. i jepen t dhnat pr 2 persona, rezultati q shtypet n ekran do t duket ashtu si sht dhn n Fig.7.46.
Fig.7.46 Pamja e ekranit pas ekzekutimit t programit fileO6
Disa fajlla t hapur njkohsisht

N nj program mund t hapen njkohsisht disa fajlla, qofshin pr shkruarje ose pr lexim. Gjat ksaj, logjika e shfrytzimit t tyre nuk dallon nga ajo kur n program kemi t bjm vetm me nj fajll t hapur. Shembull Programi fileW prmes s cilit t dhnat q shkruhen te fajlli Rrethi.txt lexohen dhe rishkruhen te fajlli RrethiK.txt . Gjat ksaj, jan t hapur njkohsisht dy fajlla sekuencial.
// Programi fileW #include <iostream> #include <fstream> #include <iomanip> using namespace std; int main() { double a=3,b=7,pi=3.1415926,r,s,p; ofstream Alfa("D:/Libra/Rrethi.txt",ios::out); for(r=a;r<=b;r=r+0.5) { s=2*pi*r; p=pi*r*r; Alfa << fixed << setprecision(2) << setw(4) << r
Fajllat 405
<< << << << << << << ' ' setw(7) s ' ' setw(7) p endl;
} cout << "\nPrundoi shkruarja te Rrethi.txt" << "\n"; Alfa.close(); ifstream Lexo("D:/Libra/Rrethi.txt",ios::in); ofstream Shkruaj("D:/Libra/RrethiK.txt",ios::out); while(!Lexo.eof()) { Lexo >> r >> s >> p; if (!Lexo.eof()) Shkruaj << fixed << setprecision(2) << setw(4) << r << ' ' << setw(7) << s << ' ' << setw(7) << p << endl; } cout << "\nPrfundoi shkruarja te RrethiK.txt" << "\n\n"; return 0; } N program, fillimisht pr vlera t ndryshme t rrezes r jan llogaritur siprfaqet s dhe perimetrat p t rrethit me rreze r. Njkohsisht, vlerat e llogaritura jan shkruar te fajlli Rrethi.txt. Pastaj, pasi mbyllet fajlli n fjal, ai rihapet pr lexim. Por, njkohsisht hapet edhe fajlli tjetr RrethiK.txt, n t cilin do t shkruhen vlerat e lexuara nga fajlli Rrethi.txt.
Nse pas prfundimit t ekzekutimit t programit hapen fajllat

Rrethi.txt dhe RrethiK.txt , duke e shfrytzuar programin Microsoft
Notepad, do t shihet se t dhnat q prfshihen brenda tyre jan t njjta, prkatsisht fajlli i dyt paraqet nj kopje t fajllit t par.
Bibliografia
1. Chris H. Pappas, William H. Murray The Complete Reference, Visual C++.Net McGraw-Hill/Osborne, New York 2002 2. Ulka Kirch-Prinz, Peter Prinz Programming in C++, A Complete Guide Jones and Bartlett Publishers, Sudbury, USA 2002 3. Julian Templeman, Andy Olsen Microsoft Visual C++.NET, Step by Step Microsoft Corporation, Redmond, Washington 2002 4. Victor Shtern Core C++, A Software Engineering Approach Prentice Hall PTR, New Jersey 2000 5. Robert Lafore Object-Oriented Programming in C++ SAMS, Indianopolis, Indiana 1999 6. Bjarne Stroustrup C++ Programming Language Addison-Wesley Publishing Company, Massachusetts 1997 7. H.M. Deitel, P. J. Deitel How to Program C Prentice Hall, Englewood Cliffs, New Jersey 1994 8. Jesse Libery Teach Yourself C++ in 21 Days Sams Publishing, Indianapolis, Indiana
408 Programimi i orientuar n objekte 9. S. B. Lippman, J. Lajoie C++ Primer Addison-Wesley Publishing Company, Massachusetts 10. Kris Jamsa, Lars Klander C/C++ Programmer's Bible Gulf Publishing Company, Houston, Texas 11. Rob McGregor Practical C++ QUE, Indianapolis, Indiana 1999 12. H.M. Deitel, P. J. Deitel How to Program C++ Prentice Hall, Upper Saddle River, New Jersey 2003 13. H.M. Deitel, P. J. Deitel How to Program C Prentice Hall, Upper Saddle River, New Jersey 2004 14. Jim Keogh, John Shapley Gray C++ Programer's Notebook Prentice Hall PTR, Upper Saddle River, New Jersey 2002 15. Agni H. Dika Algoritmet, njohuri themelore, me programe n C++ Fakulteti Elektroteknik, Prishtin 2002, 2004 16. James P. Cohoon, Jack W. Davidson C++ Program Design Irwin/McGraw-Hill, USA 1997 17. Agni Dika Bazat e programimit n C++ Fakulteti i Inxhinieris Elektrike dhe Kompjuterike, Prishtin 2004 18. D. S. Malik C++ Programming: From Problem Analysis to Program Design Course Technology, Massachusetts 2002 19. Frank L. Friedman, Elliot B. Koffman Problem Solving, Abstarction, and Design Using C++ Pearson Addison Wesley, USA 2004
Literatura 409 20. Stanley B. Lippman, Jose Lajoie, Barbara E. Moo C++ Primer, Fourth Edition Addison-Wesley, USA 2005 21. Herbert Schildt C++ from the Ground Up McGraw-Hill/Osborne, Berkeley, California 2003 22. Julian Templeman, Andy Olsen Microsoft VISUAL C++ .NET, Step by Step Microsoft Press, 2002 23. Chris H. Pappas, William H. Murray, III Visual C++ .NET, The Complete Reference McGraw-Hill/Osborne, Berkeley, California 2002
Fakulteti i Shkencave dhe i Teknologjive Bashkkohore
Universiteti i Europs Juglindore
Agni Dika Programimi i Orientuar n Objekte n C++
Lektor Dr. Ilaz Metaj
Kopertina AfiDesign Prishtin
CIP - Katalogizimi n publikim Biblioteka Popullore dhe Universitare "Sv. Kliment Ohridski", Shkup 004.432 DIKA, Agni, Programimi i Orientuar n Objekte n C++ /Agni Dika. - Tetov: ArbriaDesign, 2005. 409 faqe.; 24 cm ISBN 9989-866-25-2 a) C++ (Gjuh Programuese) - Libr pr Arsim t Lart COBISS.MK-ID 63119626

Programimi I Orientuar Ne Objekte Ne C++

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programimi I Orientuar Ne Objekte Ne C++

Uploaded by

Copyright:

Available Formats

Fakulteti i Shkencave dhe i Teknologjive Bashkkohore

Universiteti i Europs Juglindore

Programimi i Orientuar n Objekte n C++

vi Programimi i orientuar n objekte

viii Programimi i orientuar n objekte

4 Programimi i orientuar n objekte

Numrimet 7 N program, prmes deklarimit:

Degzimi prmes vlerave t numruara

Degzimi me komandn switch

"hn";break; "mart";break; "mrkur"; break; "enjte";break; "premte";break; "shtun";break; "diel";break;

u zgjodh sht dita e "

12 Programimi i orientuar n objekte

Disa variabla t numruara t tipit t njjt

Numrimet 13 Ktu, prmes komandave:

plotsisht njlloj si deklarohen variablat standarde.

Prcaktimi dhe deklarimi njkohsisht

14 Programimi i orientuar n objekte

stina=vera; rezultati q fitohet n ekran do t duket si n Fig.2.4.

Fig.2.4 Pamja e ekranit pas ekzekutimit t programit

16 Programimi i orientuar n objekte

Ktu, menjher pas komands paraprocesorike sht prcaktuar grupi

Shoqrimi direkt i vlerave

enum e { a0=k0, a1=k1, ... an=kn };

18 Programimi i orientuar n objekte

Operimi me variabla t numruara

20 Programimi i orientuar n objekte

Barazimi i variablave t numruara

cout cout cout cout cout cout

<< << << << << <<

"pes";break; "gjasht";break; "shtat";break; "tet";break; "nnt";break; "dhjet";break;

cout << "\n\n"; return 0; }

jan deklaruar variablat programim dhe vizatim t tipit nota. Me shprehjen:

variabls programim i sht shoqruar vlera tete. Kurse, prmes barazimit:

Llogaritja me vlera t numruara

22 Programimi i orientuar n objekte

sht prcaktuar vlera fillestare e variabls lule. N vijim, me shprehjen:

Variablat e numruara n unaza

24 Programimi i orientuar n objekte

"\nVlera: " lule " " g "\n"; "\n";

N program, brenda komands for sht shfrytzuar shprehja:

Fig.2.10 Pamja e ekranit pas ekzekutimit t programit

26 Programimi i orientuar n objekte

Rezultati q me kt rast shtypet n ekran, pr vlern hyrse v=10.5, do t duket si n Fig.2.11.

Fig.2.11 Pamja e ekranit pas ekzekutimit t programit

Leximi i t dhnave t numruara

28 Programimi i orientuar n objekte N program, fillimisht sht prcaktuar grupi:

n t cilin prfshihen 3 variabla. Pastaj, deklarohet variabla alfa e tipit

Fig.2.12 Pamja e ekranit pas ekzekutimit t programit

Definimi i disa grupeve njkohsisht

30 Programimi i orientuar n objekte

sepse Matematika paraqitet n t dy grupimet njkohsisht.

T dhnat e numruara n nnprograme

32 Programimi i orientuar n objekte

N programin e dhn, prmes komands:

Fig.2.14 Pamja e ekranit pas ekzekutimit t programit

34 Programimi i orientuar n objekte

Definimi i strukturave t zakonshme

Deklarimi i variablave t tipit t strukturs

Strukturat 37 N program, prmes deklarimit:

Qasja te komponentet e strukturs

38 Programimi i orientuar n objekte

Fig.3.1 Pamja e ekranit pas ekzekutimit t programit

Deklarimi direkt i variabls s strukturs

Fakt.F=1; for (i=1;i<= (2Fakt.m-Fakt.n+1);i++) Fakt.F=Fakt.Fi;

F=1; for (i=1;i<=(2m-n+1);i++) F=Fi;