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

{ int len = strlen(f);

      fio = new char[len + 1];

      if(!fio){cout<<"memory error\n"; exit(1);}

      strcpy(fio, f);

    data_rozhdenia=YEARB;

}

void Chelovek::set()

{   cout << "\n Chelovek name: ";

      cin>>fio;

      cout << endl;

      cout << "\n Data_rozhdenia: ";

      cin>> data_rozhdenia;

      cout << endl;

}

void Chelovek::get()

{cout << "\nInput Chelovek name: ";

    cout<<fio;

      cout << endl;

      cout << "\nInput Data_rozhdenia: ";

      cout<<data_rozhdenia;

      cout << endl;

}

int main()

{    char fio[80];int ye;

            Chelovek chel(fio,ye); 

      chel.set();       

      chel.get();

      return 0;}

 
 
 
 
 
 
 
 
 
 
 
 
 
 

   32.Константные объекты и функции класса.

В  С++  компоненты-функции  могут  использоваться  с  модификатором 

static и const. Обычная  компонента-функция, вызываемая  object.function(a,b);

имеет явный  список параметров a и b и неявный  список параметров, состоящий из  компонент  данных  переменной  object. Неявные  параметры можно  представить как список параметров, доступных через указатель this. Статическая (static) компонента-функция не может обращаться к любой из компонент посредством указателя this. Компонента-функция const не может изменять неявные параметры.

#include<iostream>

using namespace std;

class cls

{

      int kl;  //kol-vo izdelij

      double zp; //z/p na pr-vo 1 izdeliya

      double nl1,nl2;//2 naloga na z/pl

      double sr; // kol-vo syr'ya na pr-vo 1 izdeliya

      static double cs;

public:

      cls(){};

      ~cls(){};

      void inpt(int);

      static void vvod_cn(double);

      double seb()const;

};

double cls::cs;  //yavnoe opredelenie static-chlena v kontexte faila

void cls::inpt(int k)

{

      kl=k;

      cout<<"Vvedite z/p i 2 naloga\n";

    cin>>nl1>>nl2>>zp;

}

void cls::vvod_cn(double c)

{cs=c;  //can obrashchat'sya v f-cii only k static-komponentam

}

double cls::seb()const

{return kl*(zp+zp*nl1+zp*nl2+sr*cs);}// v f-cii nel'zya change ni odin

void main()// neyavnyj parametr(kl zp nl1 nl2 sr)

{

      cls c1,c2;

      c1.inpt(100); //inicializaciya 1-go obj

      c2.inpt(200);  //inicializaciya 2-go obj

      cls::vvod_cn(500.);

      cout<<"\nc1"<<c1.seb()<<"\nc2"<<c2.seb()<<endl;}

 
 
 
 
 
 
 
 

33.Наследование. Открытое, защищенное  и закрытое.

Наследование  –  это  одна  из  главных  особенностей  ООП.  Наследование

заключается в том, что один класс наследует  некоторые свойства другого. Этот принцип  предполагает использование базового класса, описывающего наиболее общие  свойства ряда объектов. Производные  классы включают в себя все черты базового  класса,  а  также  добавляют  новые,  характерные  только  для  объектов данного  класса.  Спецификация  описания  производного  класса имеет  следующий синтаксис:

сlass имя_производного_класса :  [атрибут]  имя_базового_класса

{тело_произв_класса} [список объектов];

Двоеточие  отделяет  производный  класс  от  базового. Как  отмечалось  ра-

нее,  ключевое  слово  class может  быть  заменено  на  слово  struct. При этом  все  компоненты  будут  иметь  атрибут  public.  Следует  отметить,  что  объединение (union) не может быть ни базовым, ни производным классом. 

Одна из особенностей порожденного класса – видимость  унаследованных

компонент базового класса. Для определения доступности  компонент базового класса  из  компонент  производного  класса  используются  ключевые  слова: private, protected и public (атрибуты базового класса). Например:

class base

{ private :          private-компоненты;

   public :           public-компоненты;

   protected :      protected-компоненты;

};

class proizv_priv :  private base { любые компоненты};

class proizv_publ : public base { любые компоненты};

class proizv_prot :  protected base { любые компоненты};

Производный класс  наследует  атрибуты компонент базового класса в за-

висимости от атрибутов базового класса следующим образом:

если базовый  класс имеет атрибут public, то компоненты public и protected

базового  класса  наследуются  с  атрибутами  public  и  protected  в  производном классе. Компоненты private остаются private-компонентами базового класса; если  базовый  класс  имеет  атрибут  protected,  то  компоненты  public  и protected  базового  класса  наследуются  с  атрибутом  protected  в  производном классе. Компоненты private остаются private-компонентами базового класса; если  базовый класс имеет атрибут private,  то  компоненты  public  и protected базового класса наследуются с атрибутами private в производном классе. Компоненты private остаются private-компонентами базового класса. Отмеченные  типы  наследования называются:  внешним,  защищенным  и внутренним наследованием.

Из этого видно, что использование атрибутов private и protected ограничи-

вает права  доступа к компонентам базового класса через производный от базового класс. Доступ  к  данным  базового  класса  из  производного  осуществляется  по имени (опуская префикс).

 

#include <iostream>

using namespace std;

#include <string.h>

#define n 10

class book                                              //  базовый класс book

{ protected:

       char naz[20];                     // название книги

        int kl;                                // количество страниц 

  public:         

        book(char *,int);               // конструктор класса book

       ~book();                            // деструктор класса book

};

class avt : public book                        //  производный класс 

 {     char fm[10];                      //  фамилия автора

  public:

        avt(char *,int,char *);       // конструктор  класса avt

        ~avt();                               // деструктор класса avt

        void see();

};

enum razd {teh,hyd,uch};

class rzd : public book                       //  производный класс  

{      razd rz;                             // раздел каталога 

  public:

        rzd(char *, int, razd);       // конструктор класса rzd

        ~rzd();                             // деструктор класса rzd

        void see();

};

book::book(char *s1,int i) : kl(i)

{ cout << "\n работает  конструктор класса   book";

   strcpy(naz,s1);

}

book::~book()

{cout << "\n работает  деструктор класса    book";}

avt::avt(char *s1,int i,char *s2) : book(s1,i)

{ cout << "\n работает  конструктор класса    avt";

   strcpy(fm,s2);

} 

avt::~avt()

{cout << "\n работает  деструктор класса    avt";}

void avt::see()

{ cout<<"\nназвание : "<<naz<<"\nстраниц : "<<kl;

}

rzd::rzd(char *s1,int i,razd tp) : book(s1,i), rz(tp)

{ cout << "\n работает  конструктор класса    rzd";

}

rzd::~rzd()

{cout << "\n работает  деструктор класса    rzd";}

void rzd::see()

{ switch(rz)

  { case teh : cout << "\nраздел технической литературы"; break;

     case hyd : cout << "\ nраздел художественной  литературы "; break;

     case uch : cout << "\ nраздел учебной литературы "; break;

  }

}

int main()

{avt av("Книга  1",123," автор1");//вызов конструкторов классов book и avt

  rzd rz("Книга  1",123,teh);         //вызов  конструкторов классов book и rzd

  av.see();

  rz.see();

}

 
 
 

34.Виртуальные  функции.

Прежде  чем  коснуться  самого  применения  виртуальных  функций,  необ-

ходимо рассмотреть  такие понятия, как раннее и позднее  связывание. 

Во время раннего  связывания вызывающий и вызываемый методы связы-

ваются при  первом удобном случае, обычно при  компиляции. 

При  позднем  связывании  вызываемого  и  вызывающего  методов  они  не

могут  быть  связаны  во  время  компиляции.  Поэтому  реализован  специальный  механизм, который определяет, как  будет происходить связывание вызываемого  и вызывающего методов, когда  вызов будет сделан фактически.  Очевидно,  что  скорость  и  эффективность при  раннем  связывании  выше, чем при использовании позднего связывания. В то же время позднее связывание обеспечивает некоторую универсальность процесса связывания.  Один из основных принципов объектно-ориентированного программирования предполагает использование идеи «один интерфейс – множество методов реализации». Эта идея заключается также в том, что базовый класс обеспечивает все  элементы, которые производные классы могут непосредственно использовать, плюс набор функций, которые производные классы должны реализовать путем их переопределения. Наряду с механизмом перегрузки функций это достигается использованием виртуальных (virtual) функций. Виртуальная функция

– это функция, объявленная с ключевым словом virtual в базовом классе и переопределенная в одном или нескольких производных от  этого классах. При вызове объекта базового или производных классов динамически (во время выполнения  программы)   определяется,  какую  из функций  требуется  вызвать,  основываясь на типе объекта. Преимущество применения виртуальных методов заключается в том, что при этом используется именно механизм позднего связывания, который допускает обработку объектов, тип которых неизвестен во время компиляции. 

#include "iostream"

#include "iomanip"

using namespace std;

#include "string.h"

class grup                               // базовый класс

{ protected: 

       char *fak;                 //  наименование факультета

       long gr;                     //  номер группы

public:

        grup(char *FAK,long GR) : gr(GR)

        {  if (!(fak=new char[20])) 

            { cout<<"ошибка выделения памяти"<<endl;