Шпаргалка по "Программированию"

Перегруженные функции. Они имеют одинаковые имена, но разное количество и\или типы параметров.

Переопределённые  функции. У них совпадает сигнатура (имя + параметры).

Они имею разную реализацию.

class A

{

      int i;

public:

      A(int ii = 0) {i = ii;}

      void show() {cout<<i<<endl;}

};

 

class B:A

{

      int j;

      public:

      B(int ii = 0, int jj = 1):A(ii) {j=jj;}

      void show()

      {cout<<j<<endl;

      A::show();

      }

};

 

void main()

{ A obj(5);

      obj.show();

 

      B obj2(7,4);

      obj.show();

}

//На  экране будет 

5 4 7

 

 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

12. Перегрузка  бинарных операторов.

тип_возвр_значения  имя_класса :: operator #(список аргументов)

{     действия, выполняемые применительно к  классу 

};

class A

{char c; int i; 

      public:

            A(int I = 0, char C = NULL);

            A(const A&);

            A operator + (A);

            friend A operator - (A,A);  

            A operator = (A);  

};

A::A(int I, char C)

{ i = I; c = C;}

 

A::A(A const &obj)

{ i=obj.i;

      c=obj.c;

}

A A::operator + (A obj)

{

      A tmp;

      tmp.i = this->i + obj.i; //a+b

      if(c>obj.c) tmp.c = c+1;

      else tmp.c = obj.c +1;

      return tmp;

}

A operator - (A obj1, A obj2)

{

      A tmp;

      tmp.i = obj1.i-obj2.i;

      if(obj1.c<obj2.c) tmp.c = obj1.c -1;

      else tmp.c = obj2.c -1;

      return tmp;

}

A A::operator = (A obj)

{

      this->i=obj.i;

      this->c=obj.c;

      return *this;

}

void main()

{

      A a(2,'a'), b(4,'b'), c, d;

      c = a+b;

      d=c=a-b;

}

 
 

13. Перегрузка  унарных операторов.
14. Перегрузка операций ++ и ––

тип_возвр_значения  имя_класса :: operator #(список аргументов)

{     действия, выполняемые применительно к  классу 

};

class A

{ int a; 

      public:

            A(int I = 0);

            A(const A&);

            A operator++();

            A operator++(int);

            friend A operator--(A &);

            friend A operator--(A &,int );

            A operator + (A);     

};

A::A(int I)

{a = I;}

 

A::A(A const &obj)

{a=obj.a;}

 

A A::operator ++(int)

{ A tmp=*this;  a++;  return tmp;

}

 

A A::operator ++()

{ a++; return *this;

}

 

A operator --(A &obj)

{ obj.a--; return obj;

}

 

A operator --(A&obj,int)

{ A tmp=obj;   obj.a--; return tmp;

}

 

A A::operator + (A obj)

{

      A tmp;

      tmp.a = this->a + obj.a;

      return tmp;

}

 

void main()

{  A ob1(2),ob2(3); 

 ob1++ + ++ob2; //2+4

}

 

15.16.21.Перегрузка  оператора().[].=

class A

{char *M;  int len; 

      public:

            A(const char * = "");

            A(const A &);

            ~A();

            char &operator[] (int);

            A operator() (int,int);

            A &operator=(const A &);

};

A::A(const char *s)

{ len = strlen(s); M = new char[len + 1]; strcpy(M, s);

}

A::A(const A &copy)

{ len = copy.len; M = new char[len + 1];  strcpy(M, copy.M);

}

A::~A()

{ delete [] M;

}

A A::operator () (int index, int len)

{ int j,i,len_new;

      char x[100]="\0"; 

      if(index>=0 && index<this->len)

      { if(this->len-index+1>=len) len_new = len;

            else len_new = this->len-index+1;       

 

            for(j=0,i=index; j<len_new; i++,j++)

                  x[j]=M[i];

            x[len_new] = '\0';

      }

      return A(x);

}

char &A::operator[] (int j)

{ assert(j >= 0 && j < len); return M[j];

}

A&  A::operator=(const A &obj)

{ if(&obj!=this)

      {

      delete []M;  this->len=obj.len; //new len stroki

      M=new char[len+1]; strcpy(M, obj.M);

      }

return *this;

}

void main()

{

A s01,s02;

 s02=s01(3,10);

}

 
 

Перегрузка  оператора   ->.

Перегрузка оператора   *.

class A

{ int a,b; 

      public:

            A(int I = 0, int J = 0);

            A(const A&);

            A *operator -> () {return this;} //подменяется obj его адресом

            A &operator * () {return *this;}

            int min();   

};

A::A(int I, int J)

{a = I; b = J;}

 

A::A(A const &obj)

{a=obj.a; b=obj.b;}

 

A::min()

{

      if(a<b) return a;

      else return b;

}

 

void main()

{

      A obj;

      A *p; p=&obj;

      p->min();

      obj->min(); //нужна была перегрузка. Станет так (&obj)->min();

}

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

19.20.Перегрузка оператора   new.Перегрузка оператора   delete.

void *operator new(size_t tip,int kol)      // глобальная функция operator

{ cout << "глобальная  функция NEW" <<endl;

   return new char[tip*kol];   // вызов системной функции  new

}

class cls

{   char a[40];

public:                 

     cls(char *aa)

     {   cout<<"конструктор класса cls"<<endl;

         strcpy(a,aa); 

     }

     ~cls(){}

     void *operator new(size_t,int);

     void operator delete(void *);

};

void *cls::operator new(size_t tip,int n)  // локальная функция operator

{ cout << "локальная  функция " <<endl;

   return new char[tip*n];   // вызов системной функции  new

}

void cls::operator delete(void *p)  // локальная функция operator

{ cout << "локальная функция DELETE" <<endl;

   delete p;               // вызов системной функции delete

}

void operator delete[](void *p)       // глобальная функция operator

{ cout << "глобальная функция DELETE" <<endl;

   delete p;               // вызов системной функции delete 

}

int main()

{ cls obj("перегрузка операторов NEW и  DELETE");

   float *ptr1;

   ptr1=new (5) float;  // вызов глобальной функции   доопр. оператора new

   delete [] ptr1;          // вызов глобальной функции   доопр. оператора delete

   cls *ptr2=new (10) cls("aa"); // вызов локальной функции доопределения

                                                 // оператора  new  (из класса cls)

   delete ptr2;                            // вызов локальной функции доопределения 

   return 0;                                 // оператора delete (из класса cls)

}

 
 
 
 
 
 
 
 
 
 
 
 

22.Inline-функции.

Вызов функции  означает переход к памяти, в которой расположен выполняемый код функции. Команда перехода занимает память и требует времени на  ее выполнение, что иногда  существенно превышает  затраты памяти на  хранение  кода  самой функции. Для  таких функций целесообразно поместить  код  функции  вместо  выполнения  перехода  к функции. В  этом  случае при выполнении функции (обращении к ней) выполняется  сразу ее код. Функции с такими свойствами являются встроенными. Иначе говоря, если описание