• Kapitulli I
  1. Shembulli 01 Komentimi i rradhëve
  2. Shembulli 2 Operatori për zona të vlershmërisë
  3. Shembulli 03 Dalja e zakonshme 'cout'
  4. Shembulli 04 Hyrje-Dalje e Regjistrave
  5. Shembulli 05 Krijimi, përkufizimi dhe dëftimi i ndryshoreve
  • Kapitulli II
  1. Shembulli 1 Vlerat e numruara të ndryshores 'enumr'
  2. Shembulli 2 Strukturat 'struct'
  3. Shembulli 3 Kalimi nga struktura në klasë 'struct'-'class'
  4. Shembulli 4 Unioni i bashkësive brenda strukturës 'struct'
  5. Shembulli 5 Kundërvlersimi i tipit të vlerave
  • Kapitulli III
  1. Shembulli 1 Veprimet me treguesin
  2. Shembulli 2 'new' dhe 'delet' për treguesin
  3. Shembulli 3 Treguesi mbi funksion
  • Kapitulli IV
  1. Shembulli 1 Prototipi i funksionit
  2. Shembulli 2 Prototipi i funksionit, dallimi nga komenti
  3. Shembulli 3 Dorzim-pranimi i referencave
  4. Shembulli 4 Parametrat standart
  5. Shembulli 5 Parametrat variues
  6. Shembulli 6 Mbingarkimi i funksionit

Shembulli 1 Struktura e thjeshtë dhe e hapurRedakto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
					    // Kapitulli 5 - Program 1 - HAPUR.CPP
#include <iostream>

struct Regjistra
{
   int MemorjaERegjistrave;
};

int main()
{
Regjistra Qeni1, Qeni2, Qeni3;
int Dosa;

   Qeni1.MemorjaERegjistrave = 12;
   Qeni2.MemorjaERegjistrave = 17;
   Qeni3.MemorjaERegjistrave = -13;
   Dosa = 123;

   std::cout << "Vlera per Qeni1 eshte " << Qeni1.MemorjaERegjistrave << "\n";
   std::cout << "Vlera per Qeni2 eshte " << Qeni2.MemorjaERegjistrave << "\n";
   std::cout << "Vlera per Qeni3 eshte " << Qeni3.MemorjaERegjistrave << "\n";
   std::cout << "Vlera per Dosa eshte " << Dosa << "\n";

   return 0;
}


// Rezulltati pas nxitimit të programit
//
// Vlera per Qeni1 eshte 12
// Vlera per Qeni2 eshte 17
// Vlera per Qeni3 eshte -13
// Vlera per Dosa eshte 123

Shembulli 2 Klasa paksa e mbrojtur nga e drejta e veprimitRedakto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
					    // Kapitulli 5 - Programi 2 - KLASA.CPP
#include <iostream>

class Kartoteka
{
   int KartotekaMemorja;
public:
   void FutVleren(int VleraEFutur);
   int NxirrVleren(void);
};

void Kartoteka::FutVleren(int VleraEFutur)
{
   KartotekaMemorja = VleraEFutur;
}

int Kartoteka::NxirrVleren(void)
{
   return KartotekaMemorja;
}

int main()
{
Kartoteka Qeni1, Qeni2, Qeni3;
int Dosa;

   Qeni1.FutVleren(12);
   Qeni2.FutVleren(17);
   Qeni3.FutVleren(-13);
   Dosa = 123;

// Qeni1.KartotekaMemorja = 115;      In C++ nicht erlaubt
// Qeni2.KartotekaMemorja = 211;      In C++ nicht erlaubt

   std::cout << "Vlera per Qeni1 eshte " << Qeni1.NxirrVleren() << "\n";
   std::cout << "Vlera per Qeni2 eshte " << Qeni2.NxirrVleren() << "\n";
   std::cout << "Vlera per Qeni3 eshte " << Qeni3.NxirrVleren() << "\n";
   std::cout << "Vlera per Dosa eshte " << Dosa << "\n";
}


// Rezulltati pas nxiimit të programit
//
// Vlera per Qeni1 eshte 12
// Vlera per Qeni2 eshte 17
// Vlera per Qeni3 eshte -13
// Vlera per Dosa eshte 123

Shembulli 3 Peripetit me të drejtat mbi të dhënat brenda klasësRedakto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
					// Kapitel 5 - Programi 3 - SHTIHAPUN.CPP
#include <iostream>

int Siperfaqja(int LartesiaEKenddrejtit, int GjersiaEKenddrejtit);

struct Kenddrejti
{
   int Lartesia;
   int Gjersia;
};

struct Shtiza
{
   int Gjatesia;
   int Thellesia;
};

int Siperfaqja(int LartesiaEKenddrejtit, int GjersiaEKenddrejtit)  //Siperfaqja e Kenddrejtit
{
   return LartesiaEKenddrejtit * GjersiaEKenddrejtit;
}

int main()
{
Kenddrejti Kuliba, Kutia;
Shtiza ShtizaEFlamurit;

   Kuliba.Lartesia = 12;
   Kuliba.Gjersia = 10;
   Kutia.Lartesia = Kutia.Gjersia = 8;

   ShtizaEFlamurit.Gjatesia = 50;
   ShtizaEFlamurit.Thellesia = 6;

   std::cout << "Siperfaqja e Kuliba-es eshte " <<
			     Siperfaqja(Kuliba.Lartesia, Kuliba.Gjersia) << "\n";
   std::cout << "Siperfaqja e Kenddrejtit eshte " <<
			     Siperfaqja(Kutia.Lartesia, Kutia.Gjersia) << "\n";
   std::cout << "Siperfaqja e ngaterrur eshte " <<
			     Siperfaqja(Kutia.Lartesia, Kuliba.Gjersia) << "\n";
   std::cout << "Siperfaqja e demeshme eshte " <<
			     Siperfaqja(Kutia.Lartesia, ShtizaEFlamurit.Thellesia) << "\n";

   return 0;
}


// Rezulltati pas nxiimit të programit
//
// Siperfaqja e Kuliba-es eshte 120
// Siperfaqja e Kenddrejtit eshte ist 64
// Siperfaqja e ngateruar eshte 80
// Siperfaqja e demeshme eshte 48

Shembulli 4 Rregullimi i së drejtes mbi të dhënat në klasëRedakto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
					// Kapitulli 5 - Programi 4 - KLASHTIZA.CPP
#include <iostream>

class Kenddrejti				// Një klasë e thjeshtë
{
   int Lartesia;
   int Gjersia;
public:
   int Siperfaqja(void);			// me dy metoda
   void Inicializo(int, int);
};

int Kenddrejti::Siperfaqja(void)		  // Siperfaqja e Kenddrejtit
{
   return Lartesia * Gjersia;
}

void Kenddrejti::Inicializo(int InitLartesia, int InitGjersia)
{
   Lartesia = InitLartesia;
   Gjersia = InitGjersia;
}

struct Shtiza
{
   int Gjatesia;
   int Thellesia;
};


int main()
{
Kenddrejti Kuliba, Kutia;
Shtiza ShtizaEFlamurit;

// Kuliba.Lartesia = 12;
// Kuliba.Gjersia = 10;
// Kutia.Lartesia = Kutia.Gjersia = 8;

   Kuliba.Inicializo(12, 10);
   Kutia.Inicializo(8, 8);

   ShtizaEFlamurit.Gjatesia = 50;
   ShtizaEFlamurit.Thellesia = 6;

   std::cout << "Siperfaqja e Kulibes eshte " <<
			     Kuliba.Siperfaqja() << "\n";
   std::cout << "Siperfaqja e Kutise eshte " <<
			     Kutia.Siperfaqja() << "\n";
// std::cout << "Siperfaqja e ngateruar eshte " <<
//			     Siperfaqja(Kutia.Lartesia, Kuliba.Gjersia) << "\n";
// std::cout << "Siperfaqja e deshme eshte " <<
//			     Siperfaqja(Kutia.Lartesia, ShtizaEFlamurit.Thellesia) << "\n";

   return 0;
}


// Rezulltati pas nxitimit të programit
//
// Siperfaqja e Kulibes eshte 120
// Siperfaqja e Kutise eshte 64

Shembulli 5 Peripetit me konstruktorët dhe destruktorëtRedakto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
                              // Kapitulli 5 - Programi 5 - KONSHTIZ.CPP
#include <iostream>

class Kenddrejti
{									 // Një klasë e thjeshtë
   int Lartesia;
   int Gjersia;
public:
   Kenddrejti(void);                  // me një konstruktor,
   int Siperfaqja(void);               // dy metoda
   void Inicializo(int, int);
   ~Kenddrejti(void);                 // dhe një destruktor.
};

Kenddrejti::Kenddrejti(void)            // Kostruktori
{
   Lartesia = 6;
   Gjersia = 6;
}

int Kenddrejti::Siperfaqja(void)         //Siperfaqja e Kenddrejtit
{
   return Lartesia * Gjersia;
}

void Kenddrejti::Inicializo(int IniLartesia, int IniGjersia)
{
   Lartesia = IniLartesia;
   Gjersia = IniGjersia;
}

Kenddrejti::~Kenddrejti(void)           // Destruktori
{
   Lartesia = 0;
   Gjersia = 0;
}

struct Shtiza
{
   int Gjatesia;
   int Thellesia;
};

int main()
{
Kenddrejti Kuliba, Kutia;
Shtiza ShtizaEFlamurit;

   std::cout << "Der Flaecheninhalt der Kuliba ist " <<
                       Kuliba.Siperfaqja() << "\n";
   std::cout << "Der Flaecheninhalt des Quadrates ist " <<
                       Kutia.Siperfaqja() << "\n";

// Kuliba.Lartesia = 12;
// Kuliba.Gjersia = 10;
// Kutia.Lartesia = Kutia.Gjersia = 8;

   Kuliba.Inicializo(12, 10);
   Kutia.Inicializo(8, 8);

   ShtizaEFlamurit.Gjatesia = 50;
   ShtizaEFlamurit.Thellesia = 6;

   std::cout << "Siperfaqja e Kulibes eshte " <<
                       Kuliba.Siperfaqja() << "\n";
   std::cout << "Siperfaqja e Kutise " <<
                       Kutia.Siperfaqja() << "\n";
// std::cout << "Siperfaqja e ngateruar eshte" <<
//                     Siperfaqja(Kutia.Lartesia, Kuliba.Gjersia) << "\n";
// std::cout << "Siperfaqja e demsheme eshte " <<
//                     Siperfaqja(Kutia.Lartesia, ShtizaEFlamurit.Thellesia) << "\n";

   return 0;
}


// Rezulltati pas nxitimit të programit
//
// Siperfaqja e Kulibes eshte 36
// Siperfaqja e Kutise eshte 36
// Siperfaqja e Kulibes eshte 120
// Siperfaqja e Kutise eshte 6464

Shembulli 6 Peripetit me module dhe modulimetRedakto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
                              // Kapitulli 5 - Programi 6 - KULIBA1.CPP
#include <iostream>

class Kuliba
{
   int Gjatesia;
   int Gjersia;
public:
   Kuliba(void);         //Konstruktori
   void Fute(int GjatesiaERe, int GjersiaERe);
   int NxirreSiperfaqja(void) {return (Gjatesia * Gjersia);}
   ~Kuliba(void);        //Destruktori
};

Kuliba::Kuliba(void)        //Implementimi i konstruktorit
{
   Gjatesia = 8;
   Gjersia = 8;
}

// Kjo metodë vendosë madhësinë për 'Kuliba' për dy parametrat
void Kuliba::Fute(int GjatesiaERe, int GjersiaERe)
{
   Gjatesia = GjatesiaERe;
   Gjersia = GjersiaERe;
}

Kuliba::~Kuliba(void)       //Implementimi i destruktorit
{
   Gjatesia = 0;
   Gjersia = 0;
}

int main()
{
Kuliba Vogel, Mesme, Madhe;          //Tri kuliba

   Vogel.Fute(5, 7);
                          // Kulba e mesme përdorë vlerat,
                          // që i jep konstruktori
   Madhe.Fute(15, 20);

   std::cout << "Siperfaqja per Kuliba e vogel eshte " << Vogel.NxirreSiperfaqja() << "\n";
   std::cout << "Siperfaqja per Kuliba e mesme eshte " << Mesme.NxirreSiperfaqja() << "\n";
   std::cout << "Siperfaqja per Kuliba e madhe eshte " << Madhe.NxirreSiperfaqja() << "\n";

   return 0;
}


// Rezulltati pas nxitimit të programit
//
// Siperfaqja per Kuliba e vogel eshte 35
// Siperfaqja per Kuliba e mesme eshte 64
// Siperfaqja per Kuliba e madhe eshte 300

Shembulli 7 Kryeregjistri i klasës 'header'Redakto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
                                     // Kapitulli 5 - Programi 7 - KULIBA.H

class Kuliba
{
   int Gjatesia;
   int Gjersia;
public:
   Kuliba(void);         //Konstruktori
   void Fute(int GjatesiaERe, int GjersiaERe);
   int NxirreSiperfaqja(void) {return (Gjatesia * Gjersia);}
   ~Kuliba(void);        //Destruktori
};


// Rezulltati pas nxitimit të programit
//
// Ky krye(header) regjistër nuk mund të kompilohet .

Shembulli 8 Implementimi i metodës së dëftuar në 'header'-regjistërRedakto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
                                   // Kapitulli 5 - Programi 8 - KULIBA.CPP
#include "kuliba.h"

Kuliba::Kuliba(void)        //Inplementimi i konstruktorit
{
   Gjatesia = 8;
   Gjersia = 8;
}

// Kjo metod vendos madhësin Kuliba mbi dy parametra
void Kuliba::Fute(int GjatesiaERe, int GjersiaERe)
{
   Gjatesia = GjatesiaERe;
   Gjersia = GjersiaERe;
}

Kuliba::~Kuliba(void)       //Implementimi i destruktorit
{
   Gjatesia = 0;
   Gjersia = 0;
}


// Rezulltati pas nxitimit të programt
//
// Ky regjistër implementues nuk mund të zbatohet si i vetëm

Shembulli 9 Përdorimi i klasësRedakto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
					  // Kapitulli 5 - Programi 9 - KULIBA2.CPP
#include <iostream>
#include "kuliba.h"

int main()
{
Kuliba Vogel, Mesme, Madhe;	     //Tri kuliba

   Vogel.Fute(5, 7);
				  // Kuliba e mesme merr vlerat,
				  // që i jep konstruktori
   Madhe.Fute(15, 20);

   std::cout << "Siperfaqja per Kuliba e vogël është " << Vogel.NxirreSiperfaqja() << "\n";
   std::cout << "Siperfaqja per Kuliba e mesme është " << Mesme.NxirreSiperfaqja() << "\n";
   std::cout << "Siperfaqja per Kuliba e madhe është " << Madhe.NxirreSiperfaqja() << "\n";

   return 0;
}


// Rezulltati pas nxitimit të programit
//
// Siperfaqja per Kuliba e vogël është 35
// Siperfaqja per Kuliba e mesme është 64
// Siperfaqja per Kuliba e madhe është 300