OOP Tutorial

    C ++ ви овозможува да наведете повеќе од една дефиниција за име на функција или оператор во истиот опсег, што се нарекува преоптоварување на функцијата и преоптоварување на операторот, соодветно.

    Преоптоварена декларација е декларација што се декларира со исто име како претходно декларирана декларација во ист опсег, освен што и двете декларации имаат различни аргументи и очигледно различна дефиниција (имплементација).

    Кога повикувате преоптоварена функција или оператор, компајлерот ја одредува најсоодветната дефиниција за употреба, споредувајќи ги типовите на аргументи што сте ги користеле за повикување на функцијата или операторот со типовите на параметар наведени во дефинициите. Процесот на избор на најсоодветна преоптоварена функција или оператор се нарекува резолуција на преоптоварување.

Преоптоварување на функциите во C ++

Може да имате повеќе дефиниции за исто име на функцијата во ист обем. Дефиницијата на функцијата мора да се разликува едни од други според видовите и / или бројот на аргументи во списокот со аргументи. Не можете да преоптоварувате декларации за функции кои се разликуваат само според типот на враќање.

Следниот е примерот кога истата функција печати () се користи за печатење на различни типови на податоци

Пример 1

#include <iostream>

using namespace std;

class printData {

public:

void print(int i) {

cout << "Pecati int: " << i << endl;

}

void print(double f) {

cout << "Pecati float: " << f << endl;

}

void print(char* c) {

cout << "Pecati character: " << c << endl;

}

};

int main(void) {

printData pd;

// Povikuva funkcija print da pecati integer

pd.print(5);

// Povikuva funkcija print da pecati float

pd.print(500.263);

// Povikuva funkcija print da pecati character

pd.print("Zdravo na site! Ova e overload - preoptovaruvanje na funkcija.");

return 0;

}

Преоптоварување на операторите во C ++

Може да ги редефинирате или преоптоварите повеќето вградени оператори достапни во C ++ и можете да ги користите тие оператори со ваши дефинирани типови.

Преоптоварените оператори се функции со посебни имиња: клучниот збор „оператор“ проследен со симболот за операторот што се дефинира. Како и секоја друга функција, преоптоварен оператор има тип на податок што треба да се врати и листа на параметри.

Пример 2

Да се дефинира класа за работа со комплексни броеви. За секој комплексен број се чуваат податоци за реалниот и имагинарниот дел.

Да се преоптоварат операторите +, ++ за извршуваање на содветните операции со комплексни броеви.

//Да се имплементира операторот << за печатење на комплексен број.

#include <iostream>

using namespace std;

class Kompleksen{

private:

int r;

int i;

public:

void setR(int a){

r=a;

}

void setI(int b){

i=b;

}

int getR(){

return r;

}

int getI(){

return i;

}

Kompleksen(int x=0, int y=0){

r=x;

i=y;

}

//~Kompleksen(){

//cout<<"Ova e destruktor na :"<<this<<endl;

//}

Kompleksen(const Kompleksen &izvor){

r=izvor.r;

i=izvor.i;

}

Kompleksen operator+(Kompleksen &sobirok);

Kompleksen operator++();

Kompleksen operator++(int);

};

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

Kompleksen Kompleksen ::operator+(Kompleksen & sobirok){

Kompleksen temp;

temp.r=r + sobirok.r;

temp.i=i+ sobirok.i;

return temp;

}

Kompleksen Kompleksen::operator++(){

Kompleksen temp;

temp.r=++r;

temp.i=++i;

return temp;

}

Kompleksen Kompleksen::operator++(int x){

Kompleksen temp;

temp.r=r++;

temp.i=i++;

return temp;

}

int main(int argc, char *argv[])

{

Kompleksen a(2,3),b(5,6),d;

d=a;

cout<<a.getR()<<endl;

cout<<a.getI()<<endl;

d=a+b;

cout<<d.getR()<<endl;

cout<<d.getI()<<endl;

return 0;

}

Пример 3

Да се дефинира класа Kutija со должина, ширина и висина. Вредностите на трите аргументи да се внесат од тастатура и да се предадат на класата со функции. Да се преоптовари операторот + .
Да се имплементира функција за пресметка на волумен.

#include <iostream>
using namespace std;

class Kutija {
   private:
      double dolzina;      // dolzina na K
      double sirina;       // sirina na K
      double visina;       // visina na K

   public:
      double getVolumen(void) {
         return dolzina * sirina * visina;
      }
      void setDolzina ( double dol ) {
         dolzina = dol;
      }
      void setSirina ( double sir ) {
         sirina = sir;
      }
      void setVisina ( double vis ) {
         visina = vis;
      }
      
      // Overload + operator da sobere dva objekti od tipot Kutija .
      Kutija operator+(const Kutija& b) {
         Kutija K;
         K.dolzina = this->dolzina + b.dolzina;
         K.sirina = this->sirina + b.sirina;
         K.visina = this->visina + b.visina;
         return K;
      }
      
};

// Main funkcija 
int main() {
   Kutija Kutija1;                // Deklaracija na  Kutija1 od tip Kutija
   Kutija Kutija2;                // Deklaracija na  Kutija2 od tip Kutija
   Kutija Kutija3;                // Deklaracija na  Kutija3 od tip Kutija
   double volumen = 0.0;          // promenliva za volumen na K 
 
   // Kutija1 specifikacii
   Kutija1.setDolzina(6.0); 
   Kutija1.setSirina(7.0); 
   Kutija1.setVisina(5.0);
 
   // Kutija2 specifikacii
   Kutija2.setDolzina(12.0); 
   Kutija2.setSirina(13.0); 
   Kutija2.setVisina(10.0);
 
   // volumen na Kutija1
   volumen = Kutija1.getVolumen();
   cout << "Volumen na Kutija1 : " << volumen <<endl;
 
   // volumen na Kutija2
   volumen = Kutija2.getVolumen();
   cout << "Volumen na Kutija2 : " << volumen <<endl;

   // Sobiranje na dva objekti :
   Kutija3 = Kutija1 + Kutija2;

   // volumen na Kutija3
   volumen = Kutija3.getVolumen();
   cout << "Volumen na Kutija3 : " << volumen <<endl;

   return 0;
}

OOП Преоптоварување на оператори