universiteti i prishtinës fakulteti i shkencave teknike të...

Universiteti i Prishtinës

Fakulteti i Shkencave Teknike të Aplikuara në Mitrovicë

dega: Informatikë Inxhinierike

Dr. sc. Bujar Shita

Programimi i orientuar në objekte në gjuhën programore C++

18-Apr-11 Version: 1

Programimi i orientuar në objekte në gjuhën programore C++ 2 / 28

Përmbajtja

1. Numërimet ( Enumerations ) .......................................................................................... 3

Përkufizimi i përgjithshëm i numërimeve ................................................................................. 3

Shoqërimi i vlerave për anëtarët në numërim .......................................................................... 4

Shoqërimi i vlerave për anëtarët në numërim mund të kontrollohet ....................................... 5

Ushtrime lidhur me numërimet ................................................................................................ 6

2. Strukturat ( Structures ) ............................................................................................... 12

Mbushja e strukturës ............................................................................................................. 14

Mbushja e strukturës me vlera të caktuara mund të bëhet edhe me vone ........................... 14

Qasja në komponentet e strukturës ....................................................................................... 14

Llogaritja me komponentet e strukturës ................................................................................ 14

të ruhen rezultatet e llogaritjes .............................................................................................. 15

Krahasimi i dy ndryshoreve të tipit strukturë ......................................................................... 16

Ndërthurja e strukturave........................................................................................................ 17

Përdorimi i strukturave në funksione ..................................................................................... 19

Brenda strukturës mund të ketë funksione ............................................................................ 20

Deklarimi i funksioneve jashtë strukturës .............................................................................. 22

Fushat në struktura ................................................................................................................ 23

Fushat e strukturave .............................................................................................................. 24

3. Klasat () ........................................................................................................................ 25

3.1 K3.p1 ............................................................................................................................. 25

3.2 K3.p2 ............................................................................................................................. 25

3.3 K2.p3. ............................................................................................................................ 25

4. Treguesit (pointers) ()................................................................................................... 26

4.1 K4.p1 ............................................................................................................................. 26

4.2 K4.p2 ............................................................................................................................. 26

Index 27


1. Numërimet ( Enumerations )

Në gjuhën C dhe C++ ekzistojnë disa mundësi të përkufizimit të konstantave.

Ta kujtojmë komandën paraprocesorike:

#define KONSTANTA VLERA

me të cilën në tërë kodin pasues bëhet zëvendësimi i fjalës se shkruar

KONSTANTA me tekstin që është shkruar në VLERA.

dhe instruksionin:

const tipi emertimi=vlera:

me të cilin deklarohet dimensioni konstanta.

p.sh. const int n=5; Këtu n=5 përkufizon p.sh. dimensionin e një vektori.

Numërimi paraqet një mundësi të re të përkufizimit të konstantave, në një

mënyrë të strukturuar. Në një grup të caktuar përkufizohen vlerat e mundshme

të konstanteve, të grupuara dhe sistemuara.

Përkufizimi i përgjithshëm i numërimeve

jepet me:

enum NUMERIMI { mundesia0, mundesia1,...,mundesiaN };

Pastaj me:

NUMERIMI ndryshorja1, ndryshorja2,...,ndryshorjaN;

deklarohen ndryshoret e tipit NUMERIMI.

Mundësive të dhëna në përkufizimin e një numërimi, në rastin e përgjithshëm u

jepen vlerat 0,1,2,....

p.sh. enum GJINIA { mashkullore, femerore, asnjanëse }

pastaj me GJINIA emer_gramatikor, peremer_gramatikor;

përkufizohe gjinia e emri dhe permerit, qe sipas gramatikës së gjuhës shqipe i

kanë tri mundësitë e lartshënuara.


Ndryshoret e numëruara mund të deklarohen edhe drejtpërdrejt:

enum NUMERIMI {

mundesia0, mundesia1,...,mundesiaN

} ndryshorja1, ndryshorja2,...,ndryshorjaN;

dhe në rast se në vazhdim të programit nuk na duhet deklarimi i ndryshoreve te

ardhme të këtij tipi, emërtimi i vetë numërimit ( NUMERIMI ) mund të

mos emërohet fare:

enum {


} ndryshorja1, ndryshorja2,...,ndryshorjaN;

p.sh. enum { Jo, Po } përgjigja;

Shoqërimi i vlerave për anëtarët në numërim

Nëse nuk përcaktohet ndryshe, do të jetë me vlerat 0,1,2,....

Kështu. Përkufizimi

enum NUMERIMI {


};

e ka si rrjedhojë shoqërimin:

mundesia0 = 0;

mundesia1 = 1;

mundesia2 = 2;

......................


Shoqërimi i vlerave për anëtarët në numërim mund të kontrollohet kjo realizohet me shoqërimin eksplicit.

p.sh.

enum Note_e_studentit {

abstenoi,

pese=5,

gjashte,

shtate,

tete,

nente,

dhjete

};

Kështu realizohet shoqërimi:

abstenoi = 0,

pese=5,

gjashte=6,

shtate=7,

tete=8,

nente=9,

dhjete=10

Vërejmë se mjafton specifikimi pese=5, që të sigurohemi rritjen me shkallën

1 të vlerave të mundësive pasuese ( gjashte, shtate,... ).


Ushtrime lidhur me numërimet

Në vijim po e paraqesim programin kryesor për dy versione te kompilatorëve,

/* Trungu i programeve per Visual Studio 6 */

#include <iostream>

#include <iomanip>

#include <string>

using namespace std; /****************************************/

/* ketu vijne nenprogramet (shembujt) ***/

/****************************************/ void main (void)

{

cout <<"Fillimi i programit"<<endl;

cout <<"-------------------"<<endl;

/***************************************/

/* ketu vijne thirrjet e nenprogrameve */

/***************************************/

cout <<"_________________________"<<endl;

cout <<"Fundi i programit kryesor"<<endl;

}/////////////////////////////////////////////////

// * Trungu i programeve per Visual Studio 2010 */ #include "stdafx.h" #include <iostream> #include <iomanip> #include <string> using namespace std; /****************************************/ /* ketu vijne nenprogramet (shembujt) ***/ /****************************************/ int _tmain(int argc, _TCHAR* argv[]) { cout <<"Fillimi i programit"<<endl; cout <<"-------------------"<<endl; /***************************************/ /* ketu vijne thirrjet e nenprogrameve */ /***************************************/ cout <<"_________________________"<<endl; cout <<"Fundi i programit kryesor"<<endl; char x; cin>>x; return 0; }/////////////////////////////////////////////////

Pasojnë detyrat me zgjidhjet e tyre, si ilustrim për materien e shpjeguar në këtë

kapitull


1.1 Detyrë. Në një moment programor është kërkuar një përgjigje nga

shfrytëzuesi. Lejohen vetëm dy mundësi: “Po” ose “Jo”.

Të shkruhet programi që i plotëson kërkesat më lartë.

Zgjidhje ///////////////////////////////////////////////////////////

void detyra11 (void){

//se pari përkufizohen përgjigjet e lejuara

//nëpërmjet Numëruesit(enumeration) Pergjigja

enum Pergjigja{ Jo, Po };

//qëllimisht fillojmë me Jo, për ta fituar numëruesin

// 0 per pergjigjen "Jo"

// 1 do t’i shoqerohet pergjigjes "Po"

Pergjigja pergjigja_aktuale;

//Me rreshtin më lartë definohet pergjigja_aktuale si një

//ndryshore e tipit Pergjigja.

// i kemi gjithsej tri raste: Po, Jo, Ndonje pergjigje tjetër.

// Mjafton t’a aktivizojme njerin nga tre rreshtat qe vijojnë

// për t’i testuar të tri rastet!

pergjigja_aktuale = Po; //+++ lejohet

// pergjigja_aktuale = Jo; //+++ lejohet

// pergjigja_aktuale = pal; //+++ nuk lejohet

cout <<"----------------------------------"<<endl;

cout <<"Pergjigja aktuale qenka "<<pergjigja_aktuale<<endl;

cout <<"----------------------------------"<<endl;

if ( pergjigja_aktuale == 1 )

cout <<"Kjo eshte pergjigje pozitive"<<endl;

if ( pergjigja_aktuale == 0 )

cout <<"Kjo eshte pergjigje negative"<<endl;

}//detyra11

///////////////////////////////////////////////////////////


1.2 Detyrë Në një moment programor është kërkuar një përgjigje nga

shfrytëzuesi. Kërkohet fleksibilitet duke lejuar pergjigjet Po, po, Yes, Jo, jo,

No. Të analizohet përgjigja dhe te cilësohet vlerëshmëria e saj duke e

aplikuar numërimin ( p.sh. Përgjigja ) me tri mundësi: Po, Jo, AsPoAsJo.

Te minimizohet kodi dhe te sqarohen aktivitetet interne të ekzekutimit

te programit.

Zgjidhje ///////////////////////////////////////////////////////

void detyra12(void){

//së pari i përkufizojmë përgjigjet e lejuara hyrëse

string per_pozitive[9]={"Po","PO","Yes","poe"};

string per_negative[9]={"Jo","JO","jo","jo","No"};

//sikur ne detyren 1.1 perkufizohen përgjigjet e lejuara

//nëpërmjet Numëruesit(enumeration) Pergjigja

//kesaj rradhe ne nje rresht, duke e perkufizuar

//edhe ndryshoren pergjigja_aktuale te tipit Pergjigja

enum Pergjigja{ AsPoAsJo, Po, Jo } pergjigja_aktuale;

//pergjiga_aktuale kesaj rradhe le te lexohet nga

string pergjigja_hyrese = "poe";

//*** Me komanden switsch reali´zohet toleranca

cout <<"----------------------------------"<<endl;

cout <<"Pergjigja hyrese qenka "<<pergjigja_hyrese<<endl;

cout <<"----------------------------------"<<endl;

pergjigja_aktuale = AsPoAsJo;

for (int i=0;i<9;i++) {

if (pergjigja_hyrese==per_pozitive[i]) {

pergjigja_aktuale = Po; break; }

if (pergjigja_hyrese==per_negative[i]) {

pergjigja_aktuale = Jo; break; }

}

cout <<"Programi yne e kuptoi si "<<pergjigja_aktuale<<endl;

//Analiza e pergjigjes mbetet e perpikte si vijon

switch ( pergjigja_aktuale ) {

case 1: cout <<"Kjo eshte pergjigje pozitive"<<endl; break;

case 2: cout <<"Kjo eshte pergjigje negative"<<endl; break;

case 0: cout <<"Kjo eshte pergjigje as po as jo"<<endl; break;

}

}//detyra12

///////////////////////////////////////////////////////////


1.3 Detyrë Në një moment programor është kërkuar nje muaj i vitit kalendarik.

I njejti duhet të përkthehet në anglishte dhe të theksohet numri i ditëve.

Muaji i zgjedhur le të shfrytëzohet si parametër hyrës.

Tabela krahasuese le te jete e kjartë për përkthyesin shqip/anglisht

nepermjet nje strukture switch.

Të shfrytëzohet numërimi dhe sa për testim le të zgjedhet muaji qershor.

Zgjidhje

///////////////////////////////////////////////////////

void detyra13 (int cilimuaj){ cout<<"detyra13-start"<<endl;

//së pari ti shfletojmë muajt e vitit në gjuhën tonë:

enum MuajiSH { ipadhene,

Janar,

Shkurt,

Mars,

Prill,

Maj,

Qershor,

Korrik,

Gusht,

Shtator,

Tetor,

Nentor,

Dhjetor } muajiSH;

cout <<"----------------------------------"<<endl;

cout <<"Si parameter hyres u zgjodh muaji "<<cilimuaj<<endl;

cout <<"----------------------------------"<<endl;

muajiSH=static_cast<MuajiSH>(cilimuaj);


cout <<"Muaji "<<cilimuaj<<" ne gjuhen angleze quhet ";

switch ( muajiSH ) {

/******************************************** translator */

case Janar: cout <<"January"<<endl; break;

case Shkurt: cout <<"February"<<endl; break;

case Mars: cout <<"March"<<endl; break;

case Prill: cout <<"April"<<endl; break;

case Maj: cout <<"May"<<endl; break;

case Qershor: cout <<"June"<<endl; break;

case Korrik: cout <<"July"<<endl; break;

case Gusht: cout <<"August"<<endl; break;

case Shtator: cout <<"September"<<endl; break;

case Tetor: cout <<"October"<<endl; break;

case Nentor: cout <<"November"<<endl; break;

case Dhjetor: cout <<"December"<<endl; break;

/******************************************** translator */


default: cout <<endl<<"??? Progami qenka i pakryer"<<endl;

cout <<"??? ose paska gabime!";

cout <<"Kerkohet intervenim!!! "<<endl;

return;

}//fundi switch

cout<<"detyra13-The End"<<endl;}

///////////////////////////////////////////////////////

Thirrja nga programi kryesor bëhet me: detyra13 ( 6 );


1.4 Detyrë Në qoftë se një numerator përmban vlera me te mëdha se një,

rekomandohet nemërimi me vlera të përcaktuara. P.sh. kur është fjala te

notat e mundshme në një provim universitar ( 5-10 ). Te shkruhet nje

program qe analizon suksesin e studentit ne nje provim.

Të shfrytëzohet numërimi dhe sa për testim le të zgjedhet nota 9.

Zgjidhje ///////////////////////////////////////////////////////

void detyra14(int si_kaloi){

//kujdes Nota (me shkronje te madhe) eshte Numerues

//kurse nota (me shkronje te vogel) eshte ndryshore

enum Nota { nuk_dihet = 0,

pese = 5,

gjashte = 6,

shtate = 7,

tete = 8,

nente = 9,

dhjete = 10 } nota;

cout <<"----------------------------------"<<endl;

cout <<"Ky student qenka notuar me noten "<<si_kaloi<<endl;

cout <<"----------------------------------"<<endl;

if (( si_kaloi >= 5 ) & ( si_kaloi <= 10 ))

nota=static_cast<Nota>(si_kaloi);

else

nota=nuk_dihet;


cout <<"Nota= "<<si_kaloi<<endl;

switch ( nota ) {

/******************************************** translator */

case pese: cout <<"Mesim dhe vetem mesim"<<endl;break;

case gjashte: cout <<"mezi kalove "<<endl; break;

case shtate: cout <<"mjedis stabil? "<<endl; break;

case tete: cout <<"mire per mesatare?"<<endl; break;

case nente: cout <<"per pak dhjeteshe?"<<endl; break;

case dhjete: cout <<"shkelqyeshem!!!"<<endl; break;

default: cout <<"kerkohet nota 5 - 10"<<endl;

};

}//fundi detyra14

///////////////////////////////////////////////////////

Thirrja nga programi kryesor bëhet me: detyra14( 9 );


2. Strukturat ( Structures )

Ne gjuhën C dhe C++ ekzistojnë vetëm 8 lloje të ndryshoreve

( bool, char, int, short, log float, double dhe long double ). Me largimin e

parashenjës për numrat e plote ( unsigned ) fitohen edhe disa lloje te

ndryshoreve. Sidoqoftë, është e qartë nevoja e mundësimit të ruajtjes,

përpunimit dhe dhënies së shënimeve më të ndërlikuara.

Strukturat janë lloje të të dhënave që ndihmojnë në këtë drejtim.

Ne rastin e përgjithshëm struktura përkufizon një lloj shënimesh që përbehet

nga llojet elementare. Këto të fundit quhen anëtarë ose komponenta të

strukturës.

struct STRUKTURE {

lloji_i_ndryshores_1 ndryshorja_1;

lloji_i_ndryshores_2 ndryshorja_2;

......

lloji_i_ndryshores_n ndryshorja_n;

} ;

p.sh. struct ADRESE_E_BANIMIT {

char rruga[30]

int numri;

char vendi[30];

char komuna[30];

char shteti[30];

} ;

Me këtë përkufizim mund të grumbullohen adresat në ndryshore, p.sh.

ADRESE_E_BANIMIT adresa_ime;

Deklarimi i ndryshoreve të tipit strukturë mund të bëhet pra:

STRUKTURE ndryshorja.


Në rastin e përgjithshëm mund të deklarohen disa ndryshore me te njëjtin lloj strukture:

STRUKTURE ndryshorja_1, ndryshorja_2,..., ndryshorja_n.

Në shembullin tonë:

ADRESE_E_BANIMIT adresa_ime, adresa_e_Agimit, adresa_e_Shaipit;

Deklarimi i ndryshoreve mund të bëhet edhe drejtpërdrejt, p.sh.

struct TREKENDESH{

int koordinata_x_e_kulmit [3];

int koordinata_y_e_kulmit [3];

} trek_ABC;

Deklarimi i ndryshoreve mund të bëhet edhe drejtpërdrejt, edhe kur na duhen

disa objekte të tilla, p.sh.

struct TREKENDESHI{

int koordinata_x_e_kulmit [3];

int koordinata_y_e_kulmit [3];

} trek_ABC, trek_DEF, trek_GHI;

Ne qoftë se strukturimi na duhet vetëm sa për ta deklaruar një ndryshore,

atëherë struktura mund të mos emërohet fare, p.sh. Këtu po e

deklarojmë një katërkëndësh ABCD pa e emëruar strukturën fare, me

supozimin që na duhen vetëm gjatësitë e brinjëve.

struct {

double brinja_AB;

double brinja_AC;

double brinja_BC;

double brinja_CD;

} katerkendeshi_ABCD;

Bën edhe me inicializim drejtpërdrejt:

struct {

double brinja[4];

} katerkendeshi_ABCD = { 4,3,4,3 };


Mbushja e strukturës me vlera të caktuara mund të bëhet me rastin e

deklarimit, veprim ky që quhet inicializim fillestar, p.sh.

ADRESE_E_BANIMIT adresa_ime =

{ “Bajram Curri”, // rruga

5, // numër

“Shipol”, // vendi

“Mitrovice”, // komuna

“Kosove”, //shteti

};

Mbushja e strukturës me vlera të caktuara mund të bëhet edhe me vone, brenda programit, duke e specifikuar sakte, elementin qe do

te mbushet.

Shembull:

adresa_ime.numer = 5;

Qasja në komponentet e strukturës behet duke e theksuar emrin e

strukturës dhe emërtimin e komponentës, të ndara me pike.

Shembull:

adresa_ime.vendi, adresa_ime. Komuna etj.

Llogaritja me komponentet e strukturës behet duke e pasur

parasysh qasjen e saktë në komponente, p.sh. Perimetri i katerkëndshit është

shuma e katër brinjëve:

Perimetri = 0;

for ( int i=0; i<4; i++) Perimetri += katerkendeshi_ABCD.brinja[i];


Në disa raste ka kuptim, brenda strukturës të ruhen rezultatet e llogaritjes me komponentet e saja, shembull:

struct {

double brinja[4];

double Perimetri, Suprina;

} katerkendeshi_ABCD = { 4.1, 3.2, 4.3, 3.5 };

Dhe llogaritja bëhet në pajtim me deklarimin më lartë:

katerkendeshi_ABCD.Perimetri = 0;

for ( int i=0; i<4; i++)

katerkendeshi_ABCD.Perimetri += katerkendeshi_ABCD.brinja[i];

Shoqërimi i dy ndryshoreve të strukturuara mund të bëhet vetëm në qoftë se

këto janë të njëjtën strukturë. Shembull: Përderisa unë dhe im vëlla banojmë në

të njëjtën banesë, dy ndryshoret me strukturën ADRESE_E_BANIMIT

mund të shoqërohen si vijon:

p.sh. struct ADRESE_E_BANIMIT { ...... };

ADRESE_E_BANIMIT adresa_ime, adresa_e_vellaut_tim;

Me shoqërimin:

adresa_e_vellaut_tim = adresa_ime;

behet shoqërimi ( pikërisht barazimi ) i komponentëve përkatëse të ndryshores

së majtë me ato të ndryshores së djathtë.


Krahasimi i dy ndryshoreve të tipit strukturë në rastin e

përgjithshëm duhet të bëhet në nivel të komponentëve. Kështu për shembull,

krahasimi i dy adresave të banimit, duhet të bëhet në secilën komponentë.

Shembull:

Nuk lejohet pyetja:

if ( adresa_e_vellaut_tim = = adresa_ime ) ...

Krahasimi duhet të bëhet në nivel te komponentëve: if (( adresa_e_vellaut_tim.rruga == adresa_ime.rruga ) &

( adresa_e_vellaut_tim.numri == adresa_ime.numri ) &

( adresa_e_vellaut_tim.vendi == adresa_ime.vendi ) &

( adresa_e_vellaut_tim.komuna == adresa_ime.komuna ) &

( adresa_e_vellaut_tim.shteti == adresa_ime. Shteti ) )

//............................................................... u plotësua kushti i barazisë!

Në rastin e përgjithshëm, në qoftë se paraqitet nevoja për shumë qasja në

anëtarët e një strukture, për t i evituar emërtimet e gjata, për qëllime praktike,

deklarohen ndryshoret me emërtime të shkurta, duke pasur parasysh llojin e

ndryshoreve. p.sh.

int nr;

nr = adresa_e_vellaut_tim.numri;

Shpeshherë është e kuptimtë, ruajtja e rezultateve të llogaritjes brenda

strukturës. p.sh.

struct {

double brinja_AB;

double brinja_AC;

double brinja_BC;

double brinja_CD;

double Perimetri;

} katerkendeshi_ABCD;

Po e japim këtu, llogaritjen e perimetrit, sa për ilustrim:

double Per = 0;

for ( int i=0; i<4; i++) Per += katerkendeshi_ABCD.brinja[i];

katerkendeshi_ABCD. Perimetri = Per;


Ndërthurja e strukturave

Ngjashëm me nënbashkësitë në teorinë e bashkësive, edhe strukturat mund të

përmbahen nga strukturat. Kemi të bëjmë me ndërthurje strukturash.

Ta marrim një shembull nga gjeometria elementare.

Trekëndëshi i ka tre kulme, tri brinjë dhe tre kënde.

Në sistemin koordinativ, çdo pike (kulmi) i shoqërohen dy koordinata,

Kështu deklarohet një kulm:

struct KULM {

double x:

double y:

};

Brinja e trekëndëshit është një segment i matshëm, prandaj deklarojmë:

struct BRINJE{

float gjatesia;

};

Këndi është po ashtu i matshëm,

struct KEND{

float madhesia;

};

Me këto struktura, mund të deklarohet trekëndëshi si mbistrukturë e tyre:

struct TREK {

KULM A, B, C; // tre kulme

BRINJE a,b,c; // tri brinje

KEND alfa, beta,gama: // tre kënde

};


Si një rast i veçantë mund ta deklarojmë strukturën për trekëndëshat

kënddrejtë,

struct TREK_KENDDREJTE {


BRINJE a,b,c; // tri brinje

KEND alfa, beta, gama=90; // njëri kënd është i drejtë

};

Te trekëndëshi kënddrejtë, brinja e madhe quhet hipotenuzë,

kurse dy brinjët e vogla quhen kateta. Duke supozuar se këndi i drejtë është

pikërisht te kulmi C, mund të deklarojmë:

struct TREK_KD{


BRINJE kateta_e_vogel;

BRINJE kateta_e_madhe;

BRINJE hypotenuza;

KEND alfa, beta;

KEND gama=90;

} td;


Përdorimi i strukturave në funksione

Strukturat mund të përdoren si parametra te funksioneve.

Shembull: Me funksionet shuma_e_kendeve, llogarite_hipotenuzen

kryhen funksionet e kërkuara dhe si rezultat jepet madhësia e kërkuar.

double shuma_e_kendeve ( TREKENDESH tx) {

double shuma=0;

shuma = tx.alfa + tx.beta + tx.gama ;

return shuma;

}

double llogarite_hipotenuzen ( TREK_KD tx) {

double c=0;

c = sqrt ( tx.a * tx.a + tx.b * tx.b );

return c;

}


Brenda strukturës mund të ketë funksione

Si anëtarë i një strukture mund të përdoren edhe funksionet.

Kështu një deklarim i përgjithësuar i strukturës e merr formën:

struct STRUKTURE {

lloji_1 ndryshorja_ose_funksioni1;

lloji_2 ndryshorja_ose_funksioni2;

...

lloji_n ndryshorja_ose_funksionin;

};

Si shembull mund ta marrim trekëndëshin kënddrejtë.

Syprina dhe perimetri i tij janë deklaruar si funksione.

struct TREK_KD{


BRINJE kateta_e_vogel;

BRINJE kateta_e_madhe;

BRINJE hypotenuza;

KEND alfa, beta;

KEND gama=90;

double Syprina ( ) {

return kateta_e_vogel * kateta_e_madhe / 2;

};

double Perimetri ( ) {

return kateta_e_vogel + kateta_e_madhe + hypotenuza;

};

} ;

Kështu, në programin thirrës, pas deklarimit: TREK_KD trek_im;

dhe pas mbushjes së anëtarëve të nevojshëm ( brinjët ) mund të kërkohen

funksionet e programuara, p.sh.

double S,P;

S = trek_im.Syprina;

P = trek_im.Perimetri;


Me përdorimin e funksioneve brenda strukturës, mund të strukturohen edhe vet funksionet. Si shembull këtu po i marrim shumën dhe

faktorielin e numrave natyror prej një gjer në n.

struct DISA_FUNKSIONE {

int n;

double shuma ( ) {

double sh;

sh = 0;

for ( int i=1; i <= n; i++) sh += i;

return sh;

};

double faktoriel ( ) {

double pr;

pr = 1;

for ( int i=1; i <= n; i++) pr *= i;

return pr;

};

} ;

Në programin thirrës, mund të bëhet deklarimi:

DISA_FUNKSIONE test;

Mbushja:

test.n = 5;

dhe thirrja

test.shuma() , test.faktoriel na jep shumën përkatësisht prodhimin e kërkuar.


Deklarimi i funksioneve jashtë strukturës

Në qoftë se kemi të bëjmë me funksione të ndërlikuara, ose më thjesht, nëse

dëshirohet deklarimi lartë – poshtë; është i lejuar deklarimi i funksioneve jashtë

strukturës, ngjashëm me prototipet e funksioneve.

Në shembullin tonë:

struct DISA_FUNKSIONE {

int n;

double shuma ( ); // shuma 1+2+...+n

double faktoriel ( ) // prodhimi 1 * 2 * ... * n

} ;

Ne vazhdim vjen pra deklarimi i funksioneve:

double DISA_FUNKSIONE :: shuma ( ) {

double sh;

sh = 0;

for ( int i=1; i <= n; i++) sh += i;

return sh;

};

double DISA_FUNKSIONE ::faktoriel ( ) {

double pr;

pr = 1;

for ( int i=1; i <= n; i++) pr *= i;

return pr;

} ;


Fushat në struktura

Brenda një strukture mund të paraqitet si anëtarë fusha e ndryshoreve madje

edhe matrica me dy ose më tepër dimensione. Kujdes të veçantë kërkon

precizomi i dimensionit të anëtarit.

Shembull: Për zgjidhjen e sistemeve lineare me dy të panjohura:

a x + b y = c

d x + e y = f

Mund te deklarohet matrica e sistemit, si bashkësi e tri kolonave:

KOLONE double;

struct SISTEM2 {

KOLONE x[2]; // koeficientet para x ( a dhe d )

KOLONE y[2]; // koeficientet para y ( b dhe e )

KOLONE lire[2]; // koeficientet e lire ( c dhe f )

}

Llogaritja e përcaktorëve ( determinanta ) thjeshtësohet me funksionin:

double llog_percaktorin ( KOLONE maj, KOLONE dja )

double rez = 0;

rez = maj.x[0] * dja.y[1] - maj.x[1] * dja.y[0];

return rez;

}

Keshtu mund të llogariten të tre përcaktorët:

P = llog_percaktorin ( sis.x, sis.y );

Px = llog_percaktorin ( sis.lire, sis.y );

Py = llog_percaktorin ( sis.x, sis.lire );

Pastaj mund të analizohet zgjedhshmëria e sistemit:

Në qoftë se P = Px = Py = 0 atëherë sistemi është i pacaktuar.

Në qoftë se P = 0 dhe së paku njeri nga Px dhe Py ndryshon nga 0,

atëherë sistemi nuk ka zgjidhje.

Përndryshe sistemi e ka një zgjidhje dhe ate:

x = Px / P

y = Py / P


Fushat e strukturave

Për të rezervuar memorie për disa objekte të të njëjtës strukturë, mund të

shfrytëzohet deklarimi i fushës së strukturave. Edhe këtu duhet pasur kujdes të

veçantë për dimensionin e anëtarit të përdorur.

Shembull: Me deklarimin e strukturës:

struct PERSON {

char emri [30];

char mbiemri [30];

int vitilin;

} ;

Pastaj me deklarimin e ndryshoreve:

PERSON studenti [ 70 ]; dhe

PERSON mesimdhenesi [ 9 ];

Përkufizohet hapësira dhe qasja për 70 student dhe 9 mesimdhënës.

Pasi të mbushen ndryshoret, qasja bëhet me indeks adekuat,

p.sh.

studenti[2].mbiemri[3]

na e përcakton shkronjën e katërt të studentit të tretë.

( Kujdes: pozicioni relativ. Fillohet me 0 )


3. Klasat ()

3.1 K3.p1

Ne gjuhën C dhe C++

.

3.2 K3.p2

...............

3.3 K2.p3.


4. Treguesit (pointers) ()

4.1 K4.p1

.............................

4.2 K4.p2


Index

brenda strukturës ................................... 15 deklarimin e strukturës ........................... 24 determinanta .......................................... 23 double Perimetri ................................... 16 drejtpërdrejt ........................................... 13 emërtime të shkurta .............................. 16 faktorielin e numrave ............................. 21 grumbullohen ......................................... 12

Krahasimi i dy ndryshoreve ..................... 16 Llogaritja me komponentet .................... 14 Mbushja e strukturës .............................. 14 mund të mos emërohet .......................... 13 Qasja në komponentet ........................... 14 ruajtja e rezultateve ............................... 16 strukturohen edhe vet funksionet ......... 21

universiteti i prishtinës fakulteti i shkencave teknike të...

Documents