Перегрузка конструктора копирования и оператора присвоения

//класс издательство
class publication
{
    protected: 
        static const int sciMAX=100;//максимальный размер символьного массива
        metring* ch_name;//название
        float f_price;//цена
    public:
        //конструктор без параметров
        publication(void);
        //конструктор с двумя параметрами
        publication(char* ch_name, float f_price);
        //конструктор копирования
        publication(publication&);
        //диструктор
        virtual~publication(void);
        //ввод данных
        virtual void put_into_the_class(void)=0;//чисто виртуальная фукция
        //вывод данных на экран консоли
        virtual void get_out_of_the_class(void);
        //оператор присвоения
        virtual publication& operator = (publication&);
};

    ch_name = val.ch_name;//копирую указатель
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    f_price = val.f_price;//копирую другое поле класса

    if(this == &val)//если объект присваивается сам себе то выход
    {return *this;}
    if(ch_name->icount==1)
    {delete ch_name;}//если больше ни кто ни указывает на эту строку то удаляем её
    else
    {ch_name->icount++;}//иначе именьшаем счётчик указателей на строку
    ch_name= val.ch_name;//копирую указатель
    f_price = val.f_price;//копирую другое поле класса
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    return *this;//возвращаю ссылку на объект

//класс книга
class book : public publication
{
    private:
        int i_how_meny_pic;//количество страниц
    public:
        //конструктор без параметров
        book(void);
        //конструктор копирования
        book(book&);
        //конструктор с тремя параметрами
        book(int,char*,float);
        //ввод данных
        void put_into_the_class(void);
        //вывод данных на экран консоли
        void get_out_of_the_class(void);
        //операция присвоения
        book& operator = (book&);
};

//конструктор копирования
book::book(book& val)
{
    ch_name = val.ch_name;//копирую указатель
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    f_price = val.f_price;//копирую другое поле класса   
    i_how_meny_pic = val.i_how_meny_pic;//копирую количество страниц в книге
}

//операция присвоения
book& book:: operator = (book& val)
{
    if(this == &val)//если объект присваивается сам себе то выход
    {return *this;}
    if(ch_name->icount==1)
    {delete ch_name;}//если больше ни кто ни указывает на эту строку то удаляем её
    else
    {ch_name->icount++;}//иначе именьшаем счётчик указателей на строку
    ch_name= val.ch_name;//копирую указатель
    f_price = val.f_price;//копирую другое поле класса
    i_how_meny_pic = val.i_how_meny_pic;//копирую количество страниц в книге
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    return *this;//возвращаю ссылку на объект
}

//класс тип
class type : public publication
{
    private:
        float f_time;//время записи книги в менутах
    public:
        //конструктор без параметров
        type(void);
        //конструктор копирования
        type(type&);
        //конструктор с тремя параметрами
        type(float,char*,float);
        //ввод данных
        void put_into_the_class(void);
        //вывод данных на экран консоли
        void get_out_of_the_class(void);
        //оператор присваения
        type& operator = (type&);
 
};

//конструктор копирования
type::type(type& val)
{
    ch_name = val.ch_name;//копирую указатель
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    f_price = val.f_price;//копирую другое поле класса   
    f_time = val.f_time;//коприрую время записи книги в минутах
}

//оператор присваения
type& type:: operator = (type& val)
{
    if(this == &val)//если объект присваивается сам себе то выход
    {return *this;}
    if(ch_name->icount==1)
    {delete ch_name;}//если больше ни кто ни указывает на эту строку то удаляем её
    else
    {ch_name->icount++;}//иначе именьшаем счётчик указателей на строку
    ch_name= val.ch_name;//копирую указатель
    f_price = val.f_price;//копирую другое поле класса
    f_time = val.f_time;//коприрую время записи книги в минутах
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    return *this;//возвращаю ссылку на объект
}

            std::cout<<"Выбирите тип книги audy или paper (a,p) :";
            std::cin>>str_val;
            if(str_val=="paper"||str_val == "p")
            {
                *(publist+n)=new book;//выделение памяти под необходимый производный класс
                (*(publist+n))->put_into_the_class();//взятие данный от пользователя
                n++;//увеличение счётчика элиментов массива
                break;//выход из внутреннего цикла
            }
            else if(str_val =="audy"||str_val == "a")//если ползователь ввел аудио книгу
            {
                *(publist+n)=new type;//выделение памяти под необходимый производный класс
                (*(publist+n))->put_into_the_class();//взятие данный от пользователя
                n++;//увеличение счётчика элиментов массива
                break;//выход из внутреннего цикла
            }

if(n>=ilenpublist)//елси не хватает места для элементов в массиве то перевыделяем память
         {
            publication** temp = new publication*[ilenpublist];//временный массив для переброски данных
            for(int i =0 ; i<ilenpublist;i++)
            {   //проверяю тип указателя и выделяю в новый временный массив соответствующую память
                if(dynamic_cast<book*>(*(publist+i)))
                {
                    *(temp+i) = new book;//выделяю память
                    *(*(temp+i))=*(*(publist+i));//побитовое копирование между объектами
                }
                //проверяю тип указателя и выделяю в новый временный массив соответствующую память
                else if(dynamic_cast<type*>(*(publist+i)))
                {
                    
                    *(temp+i) = new type;//выделяю память
                    *(*(temp+i))=*(*(publist+i));//побитовое копирование между объектами
                }
            }
            //освобождаю память для перевыдиления
            for(int i =0 ; i<ilenpublist;i++)
            {delete publist[i];}
            //выделяю новый массив на один элемент больше чем предыдуший
            publist = new publication*[n+1];//указатель на базовый класс
            //возвращаю на место уже введеный данные пользователем
            for(int i=0;i<ilenpublist;i++)
            {   //проверяю тип указателя и выделяю в новый временный массив соответствующую память
                if(dynamic_cast<book*>(*(temp+i)))
                {
                    *(publist+i) = new book;//выделяю память
                    *(*(publist+i))=*(*(temp+i));//копирование между объектами
                }
                //проверяю тип указателя и выделяю в новый временный массив соответствующую память
                else if(dynamic_cast<type*>(*(temp+i)))
                {
                    
                    *(publist+i) = new type;//выделяю память
                    *(*(publist+i))=*(*(temp+i));//копирование между объектами
                }
                
            }
            ilenpublist = n;//контроль реального количества элементов в массиве
            //освобождаю память из под временной переменной
            for(int i =0 ; i<ilenpublist-n;i++)
            {delete temp[i];}
         }

*(*(publist+i))=*(*(temp+i));//копирование между объектами

//преобразую указатель на базовый класс на указатель на соответствующий производныый
//поэлиментное копирование между объектами
*(dynamic_cast<type*>(*(publist+i)))=*(dynamic_cast<type*>(*(temp+i)));

//преобразую указатель на базовый класс на указатель на соответствующий производныый
//поэлиментное копирование между объектами
*(dynamic_cast<book*>(*(publist+i)))=*(dynamic_cast<book*>(*(temp+i)));

*(publist+i) = dynamic_cast<book*>(*(publist+i))
*(*(publist+i)) = *(*(temp+i));

publication* p1, p2;
book b1, b2;
 
p1 = &b1;
p2 = &b2;
// вызывается publication::operator= , а не book::operator= ,
// т.к. статический тип объекта, на который указывают указатели, publication
*p1 = *p2;

#include <iostream>
 
class A
{
    int x;
};
 
class B: public A
{
    int x;
};
 
int
main()
{
    B b;
    A* pb = &b;
    std::cout << sizeof b << "=" << sizeof *pb << std::endl;
    return 0;
}

*(temp+i) = new book;//выделяю память
*(*(temp+i))=*(*(publist+i));//побитовое копирование между объектами

*(temp+i) = new book;//выделяю память
*(*(temp+i))=*(*(publist+i));//побитовое копирование между объектами

*(dynamic_cast<type*>(*(temp+i)))=*(dynamic_cast<type*>(*(ipublist+i)));

*(*(temp+i))=*(*(ipublist+i));

std::cout<<typeid(*(*(temp+i))).name()<<std::endl;//type

*((book*)*(temp+i))=*((book*)*(ipublist+i));

*((book*)*(temp+i))=*((book*)*(ipublist+i));

1
 *((book*)*(temp+i))=*((book*)*(ipublist+i));

#include<iostream>
#include<string>
#include<typeinfo>
#include<conio.h>
/*В этом листенге сделано два упражнения по книге Лафоре
Идей заключается в следующем создается в динамической памяти массив указателей на базовый класс.
И процессе работы программы на уровне пользователя решается какой класс будет создан. После используя
полиморфизм вывожу данные из разных классов, на экран однотипным методом
/************************************************************************************************/
enum direction{LOWEST,DESCENDING};//перечисление направления сортировки
/**************************************************************************************************************************************/
 
class metring
{
protected:
    char* ch_pt;//для хранения выражения введённого пользователем
    int imax_fmas;//максимально количество элементов массива fmas
    int icount;//счетчик указателей на строку
    float* fmas ;//массив вещественных чисел
    //объяевление дружественных класов
    friend class publication;
    friend class book;
    friend class type;
public:
    //конструктор без параметров
    metring(void);
    //конструктор содним параметром
    metring(char* ch_c);
    //деструктор для освобождение памяти
    virtual~metring(void);
    //операция преобразования из объекта класса в float*
    operator float*(void);
    //возврат количества элементов в вещественном массиве
    int return_imax_fmas(void);
    //получение от пользователя набора чисел 
    void get_number(void);
    //оператор для преобразования из объекта в массив символов
    operator char*(void);
};
 
//конструктор без параметров
metring::metring(void):imax_fmas(1),icount(1)
{
    setlocale(LC_ALL,"Russian");//разрешаю вывод Русского языка
    ch_pt = new char[2];//первый раз выдиляю память под строку
    ch_pt[0]='\0';//принудительное указаник конца строки
    fmas = new float[imax_fmas];//создаём подходящий по размерам массив для чисел
}
//конструктор содним параметром
metring::metring(char* ch_c):icount(1)
{
    
    setlocale(LC_ALL,"Russian");//разрешаю вывод Русского языка
    ch_pt = new char[2];//первый раз выдиляю память под строку
    ch_pt[0]='\0';//принудительное указаник конца строки
    imax_fmas=1;
    fmas = new float[imax_fmas];//создаём подходящий по размерам массив для чисел  
 
    
    if(strlen(ch_c)>1)
    {delete []ch_pt;}//освобождаю ранее выделенную память т.к. она не достаточна для хранения новой строки 
    ch_pt = new char [strlen(ch_c)+1];
    ch_pt[0]='\0';//принудительное указаник конца строки
    strcpy(ch_pt,ch_c);
    ch_pt[strlen(ch_c)]='\0';//принудительное указаник конца строки
}
//деструктор для освобождение памяти
metring::~metring(void)//освобождаю память
{delete []ch_pt;delete []fmas;}
//получение от пользователя набора чисел 
void metring::get_number(void)
{
    int ilen = 1;//для хранения длинны строки
    char* ch_pt_temp ;//временный банк для обмена
    char ch_temp[2]="e";//инициализация любым значение отличным от нуля и не равным 13(знаку Enter)
    //создание строки необходимого размера для хранения строки ch_c
    while(ch_temp[0]!=13)//продолжать пока пользователь не нажмёт клавишу Enter
    {
        ch_pt_temp = new char[strlen(ch_pt)+2];//выделяю память под переменную для обмена
        ch_pt_temp[0]='\0';//принудительное указаник конца строки          
        bool flag=true;//флаг для инкримента счетчика символов
        ch_temp[0] = getche();//отобразить символ и записать его значение в переменную типа char
        if(ilen!=1&&ch_temp[0]!=13)//если ilen!=1 и ch_temp!=Enter 
        {                                   //  то освобождаем память для перевыдиления
            //перед освобождением памяти делаю копию значения строки
            //копируем сиволы в нашу строку с нулевым символом
        
            for(int i = 0, r = strlen(ch_pt_temp); i < strlen(ch_pt)+1;i++,r++)
            {
                ch_pt_temp[r]=ch_pt[i]; 
            }
            ch_pt_temp[strlen(ch_pt_temp)+1];//принудительное завершение строки
            delete []ch_pt;//освобождаю выделенную память
            if(ch_temp[0]==8&&strlen(ch_pt_temp))
            {
                std::cout<<"\x20\x08";//затираем предыдущий символ знаком пробела и перемещаем курсор
                ilen--;//уменьшаем значение количество символов в строке
                flag=false;
            }
            else if(ch_temp[0]==8&&strlen(ch_pt_temp)<=0)
            {
                std::cout<<"\x3A";
            }
            ch_pt=new char[ilen+2];//заного выделяю память 1 для нового сивола другой для знака \0 конца строки
            ch_pt[0]='\0';//принудительное указаник конца строки
            //возвращаю значение строки предшествующие перевыдилинию памяти
            //копируем сиволы в нашу строку с нулевым символом
            int itemplen=(strlen(ch_pt_temp)==ilen-2)?ilen-1:ilen;
            for(int i = 0, r = strlen(ch_pt); i < itemplen+1;i++,r++)
            {
                ch_pt[r]=ch_pt_temp[i]; 
            }
            if(strlen(ch_pt_temp)!=ilen-2)
            {ch_pt[ilen-1]='\0';}
            
        }
        if(ch_temp[0]!=13&&ch_temp[0]!=8)//если ch_temp!=Enter помещаем символ в строку
        {
            //копируем сиволы в нашу строку с нулевым символом
            for(int i = 0, r = strlen(ch_pt); i < strlen(ch_temp)+1;i++,r++)
            {
                ch_pt[r]=ch_temp[i];    
            }
            
        }
        delete[]ch_pt_temp;//освобождаем память
        if(flag)
        {ilen++;}//инкременация счетчика символов
    }
    imax_fmas=ilen;//запись количества символов
    std::cout<<std::endl;//производим действия клавиши Enter
}
 
//операция преобразования из объекта класса в float*
metring:: operator float*(void)
{
    char* ch_pt_temp ;//временный банк для обмена
    int isecondlen=2,//разряд числа
        idex=0;//индекс массива который представляет одно число
    bool flag= true;//флаг для разрешения выдиления памяти для ch_pt_temp
    
    //разбираем массив т.е. отдиляем числа от запятых, целые от вещественных
    for(int i = 0; i<strlen(ch_pt);i++)
    {
        if(flag)//выделяем каждый раз когда следует отдельное число 
        {
            ch_pt_temp = new char[isecondlen];//выделяю память под переменную для обмена
            ch_pt_temp[0]='\0';//принудительное указаник конца строки
            flag=false;//запрещаем перевыдиление памяти пока не закочится число
        }
        
        if(isecondlen>strlen(ch_pt_temp)&&(strlen(ch_pt_temp)!=0)&&ch_pt[i]!=',')
        {
            char* ch_pt_temp2 = new char[isecondlen+2];//выделяю память для временной переменной
            ch_pt_temp2[0]= '\0';//принудительно инициализирую её первый символ нулём
            //копируем сиволы в нашу строку с нулевым символом
            for(int i = 0, r = strlen(ch_pt_temp2); i < strlen(ch_pt_temp)+1;i++,r++)
            {
                ch_pt_temp2[r]=ch_pt_temp[i];   
            }
            delete []ch_pt_temp;//освобождаю память
            //выделяю памяти больше на одну единицу
            ch_pt_temp = new char[isecondlen+2];//выделяю память под переменную для обмена
            ch_pt_temp[0]= '\0';//принудительно инициализирую её первый символ нулём
 
            //копируем сиволы в нашу строку с нулевым символом
            for(int i = 0, r = strlen(ch_pt_temp); i < strlen(ch_pt_temp2)+1;i++,r++)
            {
                ch_pt_temp[r]=ch_pt_temp2[i];   
            }
            delete []ch_pt_temp2;//освобождаю память
        }
        if(ch_pt[i]!=',')//если символ не является разделительным символом то просто копируем цифру
        {
            ch_pt_temp[idex++]=ch_pt[i];//копируем символ
            ch_pt_temp[idex]= '\0';//принудительное завершение строки
            isecondlen++;//увеличиваем разряд числа
        }
        if(ch_pt[i]==','||(i+1>=strlen(ch_pt)))//если символ разделительный то переобразуем массив ch_pt_temp в float
        {
            
            isecondlen=2;//инициализируем  флаг на 1 следящий за разрядом числа
            flag=true;//разрешаем перевыдиление памяти т.к. число закончилось
            if(imax_fmas)//если не нулевое значение значит нужно перевыделить память для вещественного массива
            {
                float* f_mas_temp = new float[imax_fmas];//создаю временный массив для страховки основного массива fmas
                for(int e =0 ; e<imax_fmas;e++)
                {
                    f_mas_temp[e]=fmas[e];//копирую значения массива
                }
                delete []fmas;//освобождаю память
                fmas = new float[imax_fmas+1];// перевыдиляю память
                for(int e =0 ; e<imax_fmas;e++)
                {
                    fmas[e]=f_mas_temp[e];//копирую значения массива
                }
                delete[]f_mas_temp;//освобождаю выделенную память
            }
            ch_pt_temp[idex]='\0';//принудительно завершаю строку нулевым символом
            idex = 0;//обнуление индекса
            //проверка числа т.е. было оно целым или вещественным путем поиска символа '.'
            for(int k = 0 ; k<strlen(ch_pt_temp);k++)
            {
                if(ch_pt_temp[k]=='.')//если такой символ есть то меняю его на ',' так требует atof
                {ch_pt_temp[k]=',';}
            }
 
            //преобразуем массив символов в вещественное число
            fmas[imax_fmas-1] = atof(ch_pt_temp);
            if(!(i+1>=strlen(ch_pt)))
            {imax_fmas++;}//увеличиваем число элементов в вещественном массиве
            delete[]ch_pt_temp;//освобождение памяти для массива для представления любого числа
        }
        
    }
    return (fmas);//возвращаю массив чисел типа float
}
//оператор для преобразования из объекта в массив символов
metring:: operator char*(void)
{ return (ch_pt); }
//возврат количества элементов в вещественном массиве
int metring:: return_imax_fmas(void)
{return(imax_fmas);}
/**************************************************************************************************************************************/
//класс издательство
class publication
{
    protected: 
        static const int sciMAX=100;//максимальный размер символьного массива
        metring* ch_name;//название
        float f_price;//цена
    public:
        //конструктор без параметров
        publication(void);
        //конструктор с двумя параметрами
        publication(char*, float);
        //конструктор копирования
        publication(publication&);
        //диструктор
        virtual~publication(void);
        //ввод данных
        virtual void put_into_the_class(void)=0;//чисто виртуальная фукция
        //вывод данных на экран консоли
        virtual void get_out_of_the_class(void);
        //оператор присвоения
        virtual publication& operator = (publication&);
};
publication::publication(char* ch_name, float f_price):f_price(f_price)
{
    setlocale(LC_ALL,"russian");//разрешаю вывод Русского языка
    publication::ch_name = new metring(ch_name);//выделяю память под строку и инициализирую массив переданным значением
}
publication::publication(void):f_price(0.0F)
{
    ch_name = new metring;//выделяю память под строку
    setlocale(LC_ALL,"russian");//разрешаю вывод Русского языка
}
//конструктор копирования
publication::publication(publication& val)
{
    ch_name = val.ch_name;//копирую указатель
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    f_price = val.f_price;//копирую другое поле класса
}
//диструктор
publication::~publication(void)
{   if(ch_name->icount==1)
    {delete ch_name;}//если больше ни кто ни указывает на эту строку то удаляем её
    else
    {ch_name->icount++;}//иначе именьшаем счётчик указателей на строку
 
}//освобождение памяти, а точнее вызов диструктора строки 
//оператор присвоения
publication& publication:: operator = (publication& val)
{
    if(this == &val)//если объект присваивается сам себе то выход
    {return *this;}
    if(ch_name->icount==1)
    {delete ch_name;}//если больше ни кто ни указывает на эту строку то удаляем её
    else
    {ch_name->icount++;}//иначе именьшаем счётчик указателей на строку
    ch_name= val.ch_name;//копирую указатель
    f_price = val.f_price;//копирую другое поле класса
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    return *this;//возвращаю ссылку на объект
}
//ввод данных
void publication:: put_into_the_class(void)
{
    std::cout<<"Введите название : ";
    ch_name->get_number();//получение от пользователя динамической строки символов
    std::cout<<"Введите цену : ";
    std::cin>>f_price;
}
//вывод данных на экран консоли
void publication:: get_out_of_the_class(void)
{
    std::cout<<"Название : "<<ch_name->ch_pt<<std::endl;
    std::cout<<"Цена : "<<f_price<<std::endl;
}
 
/*************************************************************************************************************/
//класс книга
class book : public publication
{
    private:
        int i_how_meny_pic;//количество страниц
    public:
        //конструктор без параметров
        book(void);
        //конструктор копирования
        book(book&);
        //конструктор с тремя параметрами
        book(int,char*,float);
        //ввод данных
        void put_into_the_class(void);
        //вывод данных на экран консоли
        void get_out_of_the_class(void);
        //операция присвоения
        book& operator = (book&);
};
//конструктор с тремя параметрами
book::book(int i_pictures,char* ch_name, float f_price) :i_how_meny_pic(i_pictures),publication(ch_name,f_price)
{setlocale(LC_ALL,"Russian");/*разрешаю вывод Русского языка*/}
//конструктор без параметров
book::book(void):publication(),i_how_meny_pic(0)
{setlocale(LC_ALL,"Russian");/*разрешаю вывод Русского языка*/}
//конструктор копирования
book::book(book& val)
{
    ch_name = val.ch_name;//копирую указатель
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    f_price = val.f_price;//копирую другое поле класса   
    i_how_meny_pic = val.i_how_meny_pic;//копирую количество страниц в книге
}
//операция присвоения
book& book:: operator = (book& val)
{
    if(this == &val)//если объект присваивается сам себе то выход
    {return *this;}
    if(ch_name->icount==1)
    {delete ch_name;}//если больше ни кто ни указывает на эту строку то удаляем её
    else
    {ch_name->icount++;}//иначе именьшаем счётчик указателей на строку
    ch_name= val.ch_name;//копирую указатель
    f_price = val.f_price;//копирую другое поле класса
    i_how_meny_pic = val.i_how_meny_pic;//копирую количество страниц в книге
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    return *this;//возвращаю ссылку на объект
}
 
//ввод данных
void book:: put_into_the_class(void)
{
    publication::put_into_the_class();//вызов метода базового классa
    std::cout<<"Введите количество страниц : ";//получение количества страниц от пользователя
    std::cin>>i_how_meny_pic;
}
//вывод данных на экран консоли
void book:: get_out_of_the_class(void)
{
    publication::get_out_of_the_class();//вызов метода базового класса
    std::cout<<"Количество страниц : "<<i_how_meny_pic<<std::endl;//вывод на экран консоли значения кол-ва страниц
}
 
/*************************************************************************************************************/
//класс тип
class type : public publication
{
    private:
        float f_time;//время записи книги в менутах
    public:
        //конструктор без параметров
        type(void);
        //конструктор копирования
        type(type&);
        //конструктор с тремя параметрами
        type(float,char*,float);
        //ввод данных
        void put_into_the_class(void);
        //вывод данных на экран консоли
        void get_out_of_the_class(void);
        //оператор присваения
        type& operator = (type&);
 
};
//конструктор с тремя параметрами
type::type(float f_time,char* ch_name, float f_price) : publication(ch_name,f_price),f_time(f_time)
{setlocale(LC_ALL,"Russian");/*разрешаю вывод Русского языка*/}
//конструктор без параметров
type::type(void):publication(),f_time(0.0F)
{setlocale(LC_ALL,"Russian");/*разрешаю вывод Русского языка*/}
//конструктор копирования
type::type(type& val)
{
    ch_name = val.ch_name;//копирую указатель
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    f_price = val.f_price;//копирую другое поле класса   
    f_time = val.f_time;//коприрую время записи книги в минутах
}
//оператор присваения
type& type:: operator = (type& val)
{
    if(this == &val)//если объект присваивается сам себе то выход
    {return *this;}
    if(ch_name->icount==1)
    {delete ch_name;}//если больше ни кто ни указывает на эту строку то удаляем её
    else
    {ch_name->icount++;}//иначе именьшаем счётчик указателей на строку
    ch_name= val.ch_name;//копирую указатель
    f_price = val.f_price;//копирую другое поле класса
    f_time = val.f_time;//коприрую время записи книги в минутах
    ch_name->icount++;//увеличиваю счётчик указывающий на количество указателей на строку
    return *this;//возвращаю ссылку на объект
}
//ввод данных
void type:: put_into_the_class(void)
{
    publication::put_into_the_class();//вызов метода базового классa
    std::cout<<"Введите время записи книги в минутах : ";//получение времени записи от пользователя
    std::cin>>f_time;
}
//вывод данных на экран консоли
void type:: get_out_of_the_class(void)
{
    publication::get_out_of_the_class();//вызов метода базового класса
    std::cout<<"Время записи книги в минутах : "<<f_time<<std::endl;//вывод на экран консоли значения кол-ва страниц
}
 
/*************************************************************************************************************/
 int main(void)
 {
     std::string str_val;
     int ilenpublist=1;//длинна массива 
     int n=0;//счётчик элиметна массива
     class publication** publist = new publication*[ilenpublist];//указатель на базовый класс
     char ch_chose = 'd';//флаг для выхода из цикла
     do
     {
         ch_chose = 'd';//сброс флага
         if(n>=ilenpublist)//елси не хватает места для элементов в массиве то перевыделяем память
         {
            publication** temp = new publication*[ilenpublist];//временный массив для переброски данных
            for(int i =0 ; i<ilenpublist;i++)
            {   //проверяю тип указателя и выделяю в новый временный массив соответствующую память
                if(dynamic_cast<book*>(*(publist+i)))
                {
                    *(temp+i) = new book;//выделяю память
                    //преобразую указатель на базовый класс на указатель на соответствующий производныый
                    *(dynamic_cast<book*>(*(temp+i)))=*(dynamic_cast<book*>(*(publist+i)));//побитовое копирование между объектами
                }
                //проверяю тип указателя и выделяю в новый временный массив соответствующую память
                else if(dynamic_cast<type*>(*(publist+i)))
                {
                    
                    *(temp+i) = new type;//выделяю память
                    //преобразую указатель на базовый класс на указатель на соответствующий производныый
                    *(dynamic_cast<type*>(*(temp+i)))=*(dynamic_cast<type*>(*(publist+i)));//побитовое копирование между объектами
                }
            }
            //освобождаю память для перевыдиления
            for(int i =0 ; i<ilenpublist;i++)
            {delete publist[i];}
            //выделяю новый массив на один элемент больше чем предыдуший
            publist = new publication*[n+1];//указатель на базовый класс
            //возвращаю на место уже введеный данные пользователем
            for(int i=0;i<ilenpublist;i++)
            {   //проверяю тип указателя и выделяю в новый временный массив соответствующую память
                if(dynamic_cast<book*>(*(temp+i)))
                {
                    *(publist+i) = new book;//выделяю память
                    //преобразую указатель на базовый класс на указатель на соответствующий производныый
                    *(dynamic_cast<book*>(*(publist+i)))=*(dynamic_cast<book*>(*(temp+i)));//побитовое копирование между объектами
                }
                //проверяю тип указателя и выделяю в новый временный массив соответствующую память
                else if(dynamic_cast<type*>(*(temp+i)))
                {
                    
                    *(publist+i) = new type;//выделяю память
                    //преобразую указатель на базовый класс на указатель на соответствующий производныый
                    *(dynamic_cast<type*>(*(publist+i)))=*(dynamic_cast<type*>(*(temp+i)));//побитовое копирование между объектами
                }
                
            }
            
            //освобождаю память из под временной переменной
            for(int i =0 ; i<ilenpublist;i++)
            {delete temp[i];}
            ilenpublist = n+1;//контроль реального количества элементов в массиве
         }
 
         while(1)//цикл для удачного ввода данных о типе книги
         {
            SYSTEMCRACH: //вернёмся сюда если пользователь ввел не правильный тип книги
            book::book();//вызов конструктора для разрешения русского языка
            std::cout<<"Выбирите тип книги audy или paper (a,p) :";
            std::cin>>str_val;
            if(str_val=="paper"||str_val == "p")
            {
                *(publist+n)=new book;//выделение памяти под необходимый производный класс
                (*(publist+n))->put_into_the_class();//взятие данный от пользователя
                n++;//увеличение счётчика элиментов массива
                break;//выход из внутреннего цикла
            }
            else if(str_val =="audy"||str_val == "a")//если ползователь ввел аудио книгу
            {
                *(publist+n)=new type;//выделение памяти под необходимый производный класс
                (*(publist+n))->put_into_the_class();//взятие данный от пользователя
                n++;//увеличение счётчика элиментов массива
                break;//выход из внутреннего цикла
            }
            else
            {
                std::cout<<"ОШИБКА не допустимый выбор! Попробуйте ещё раз!\n";
                goto SYSTEMCRACH;//переход в начало внутреннего цикла
            }
         }
         //опрос пользователя о продолжении цикла
         for(;ch_chose!='n' && ch_chose!='y';)//цикл законциться тогда когда пользователь введет y или n
         {
            std::cout<<"Продолжить ввод (y,n) : ";
            std::cin>>ch_chose;
            if(ch_chose!='n' && ch_chose!='y')
            {
                std::cout<<"Ошибка, Вы ввели не допустимый символ ("<<ch_chose
                      <<") попробуйте ещё раз!\n";
            }
         }
 
     }while(ch_chose!='n');
     //вывод данный на экран
     std::cout<<std::endl;
     for(int i =0;i<n;i++)
     {
        publist[i]->get_out_of_the_class();
     }
     //освобождаю память для перевыдиления
    for(int i =0 ; i<n;i++)
    {delete publist[i];}
     system ("pause");
 return 0;
 }