Указатели,массивы символов и динамическая память - C++ - Ответ 2454450

#include<iostream>
#include<conio.h>
#include<string>
#include<stdlib.h>
 
/**************************************************************************************************************************************/
 
class metring
{
protected:
    char* ch_pt;//для хранения выражения введённого пользователем
    int imax_fmas;//максимально количество элементов массива fmas
    float* fmas ;//массив вещественных чисел
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)
{
    setlocale(LC_ALL,"Russian");//разрешаю вывод Русского языка
    ch_pt = new char[2];//первый раз выдиляю память под строку
    ch_pt[0]='\0';//принудительное указаник конца строки
    fmas = new float[imax_fmas];//создаём подходящий по размерам массив для чисел
}
 
//конструктор содним параметром
metring::metring(char* ch_c)
{
    
    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;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;//запись количества символов
}
 
//операция преобразования из объекта класса в 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 String : private metring
{
private:
    char** ch_pt_week;//указатель на календарь недели
    enum direction{LOWEST,DESCENDING}directory;//направление сортировки
    int ciDAYOFWEEK;//максимальный размер внешнего измерения массива
public:
    //конструктор без параметров
    String(void);
    //конструтрор с двумя параметрами
    String( char** cch_pt, const int ciSIZE);
    //диструктор для освобождения памяти
    ~String(void);
    //получить дни недели от пользоватля
    void get_days_of_week(void);
    //вывод на экран дней нидели
    void show_day_of_week(void);
    //сортировка указателей по алфовиту по возрастанию или убыванию
    void sort_days_of_week(const direction*const);
    //увеличение строки путём приклейвания символов и перераспредиления памяти
    void strcat(const char* =""  ,const bool =false);
    //перевыдиление памяти внутриннего измерения
    void realoc(char*,const int&);
    //перевыдиление памяти внешнего измерения
    void realoc(char**,const int&);
};
//конструктор без параметров
String::String(void):ciDAYOFWEEK(7),metring()
{
    setlocale(LC_ALL,"Russian");//разрешаю вывод Русского языка
    ch_pt_week = new char*[ciDAYOFWEEK];//выделяю память для дней недели 
    for(int i = 0; i <ciDAYOFWEEK; i++)
    {
        switch(i)
        {
            case 0:
                    *(ch_pt_week+i) = new char[strlen("Monsday")];
                    break;
            case 1:
                    *(ch_pt_week+i) =  new char[strlen("Tuesday")];
                    break;
            case 2:
                    *(ch_pt_week+i) =  new char[strlen("Wednesday")];
                    break;
            case 3:
                    *(ch_pt_week+i) =  new char[strlen("Thursday")];
                    break;
            case 4:
                    *(ch_pt_week+i) =  new char[strlen("Friday")];
                    break;
            case 5:
                    *(ch_pt_week+i) =  new char[strlen("Saturday")];
                    break;
            case 6:
                    *(ch_pt_week+i) =  new char[strlen("Sunday")];
                    break;
        }
    }
}
//конструтрор с двумя параметрами
String::String( char** cch_pt, const int ciSIZE):ciDAYOFWEEK(ciSIZE)
{
    setlocale(LC_ALL,"Russian");//разрешаю вывод Русского языка
    ch_pt_week = new char* [ciSIZE];//выделяю достаточное количество для хранения календаря память
    
     for(int i =0; i < ciSIZE; i++)//копирую значения массива
     {
        *(ch_pt_week+i)= new char[strlen(*(cch_pt+i))+1];//сначало выделяю память
        strcpy(*(ch_pt_week+i),*(cch_pt+i));//после копирую значения
     }
}
 
//диструктор для освобождения памяти
String::~String(void)
{
    for(int i=0;i<ciDAYOFWEEK;i++)//освобождаю память из под двумерного массива указателей
    {delete ch_pt_week[i];}
}
//увеличение строки путём приклейвания символов и перераспредиления памяти
void ::String:: strcat(const char* cchc  ,const bool cbflag )
{
      static int si_sizea;//для подстчета элемента массива
    if(ch_pt[strlen(ch_pt)]=='\0'&& !cbflag)//если строки не хватает то перевыделяем память
    {
        char* ch_ptemp = new char [strlen(ch_pt)+1];//созадю временную строку  для обмена
        strcpy(ch_ptemp,ch_pt);//дублирую содержимое поля
        delete []ch_pt;//освобождаю не подходящую по размерам память
        ch_pt = new char[strlen(ch_ptemp)+2];//перевыделяю память на один символ 1 байт больше
        strcpy( ch_pt,ch_ptemp);//возращаю содержимое поля
        ch_pt[strlen(ch_ptemp)] = '\0';//принудительно указываю конец строки
        delete []ch_ptemp;//освобождаю память для ненужных банков
    
    }
    if(!cbflag)
    {
        //приклеиваю к строке приходящий символ символ\
        поиск нулевого символа
        int isymb=0;
        
        for(int i = 0 ; i<strlen(ch_pt)+2;i++)
        {
            if(ch_pt[i]=='\0')
            {isymb = i;}
        }
            
 
            ch_pt[isymb]=*(cchc+si_sizea);
            ch_pt[isymb+1]='\0';
                
 
    }
//мы перевыделяем память на минимум т.е один символ с учётом нулевого
    else if(cbflag)
    {
        delete []ch_pt;//освобождаю не подходящую по размерам память
        ch_pt = new char[2];//перевыделяю память
        *ch_pt = '\0';//принудительно указываю конец строки
    }
    si_sizea++;
}
//перевыдиление памяти внешнего измерения
void ::String:: realoc(char** cchpt ,const int& isize)
{
    char** ch = new char*[ciDAYOFWEEK];//временная переменная для перевыдиления памяти
    for(int i = 0;i<ciDAYOFWEEK;i++)//выделяю память для внутренних измерений
    {
        *(ch+i) = new char[strlen(*(cchpt+i))];
    }
    for(int i = 0;i<ciDAYOFWEEK;i++)//теперь дублирую значения всей матрицы
    {
        strcpy(*(ch+i),*(cchpt+i));
    }
    for(int i = 0;i<ciDAYOFWEEK;i++)//освобождаю не достаточный блок памяти
    {delete cchpt[i];}
    
    char** cchpt = new char*[ciDAYOFWEEK+isize];//перевыделяю память на  isize еденицы больше
    for(int i = 0;i<ciDAYOFWEEK+isize;i++)//выделяю память для внутренних измерений
    {
        if(i<ciDAYOFWEEK)
        {*(cchpt+i) = new char[strlen(*(ch+i))];}//перевыделяю память в соответсвие со значениями
        else
        {
            *(cchpt+i) = new char[2];//иначе выделяю минимум для одного символа
        }
    }
    for(int i = 0;i<ciDAYOFWEEK+isize;i++)//возвращаю все значения матрицы
    {
        if(i<ciDAYOFWEEK)
        {strcpy(*(cchpt+i),*(ch+i));}
        else
        {
            *(cchpt+i)='\0';//прунудительно указываю конец строки во избежания подводных камней
        }
    }
    ciDAYOFWEEK+=isize;//изменение счётчика 
}
//перевыдиление памяти внутреннего измерения
void ::String:: realoc(char* cchpt,const int& isize)
{
    char* ch = new char[strlen(cchpt)+1];//временная переменная для перевыдиления памяти
    strcpy(ch,cchpt);//дублирование значиния строки
    delete []cchpt;//освобождение памяти
    cchpt = new char[strlen(ch)+isize];//перевыдиление памяти больше на 1 байт
    *cchpt= '\0';//принудительное указание конца строки
    strcat(cchpt,ch);//приклеиваю строку
    cchpt[strlen(ch)-1]= '\0';//принудительное указание конца строки
}
//получить дни недели от пользоватля
void ::String:: get_days_of_week(void)
{
    int ciDAYOFSYMBOL;//максимальный размер внутреннего измерения массива
    int ilen=0;//для слижения за пределами массива
    String String_temp;//временный объект для хранения строки
    
    std::cout<<"Введите дни недели через запятую :";
    String::get_number();//вызов метода базового класса
 
    int ite=0;//для подсчета слова
    
    //разбор строки т.е. распредиление названий недели по массивам
    for(int i =0,k=0 ;i <imax_fmas;i++)
    {
        if(*(ch_pt+i)!=','&&*(ch_pt+i)!='\0')
        {
            String_temp.strcat(ch_pt);//копирую символы в динамический массив
            ite++;
        }
        else
        {
            ilen++;//увеличиваю счётчик предела массива
            if(!(ilen<ciDAYOFWEEK))//если у нас не достаточно памяти для внешнего измерения массива ch_pt_week
            {                       // то перевыдиляю память для внешнего измерения массива ch_pt         
                //вычисляем на скользо необходимо увеличить строку 
                int itemp =(ilen==ciDAYOFSYMBOL)?1:(ilen-ciDAYOFSYMBOL+1);
                //перевыделяем память для строки на itemp
                realoc(ch_pt_week,itemp);
            }
            ciDAYOFSYMBOL = strlen(*(ch_pt_week+k));//получаю размер строки
            if(!(ciDAYOFSYMBOL>ite-1))//если строка не помещается
            {                                                           //то перевыдиляю память
                
                //вычисляем на скользо необходимо увеличить строку 
                int itemp = (ciDAYOFSYMBOL==ite-1)? 1:(ite - ciDAYOFSYMBOL+1);
                //перевыделяем память для строки на itemp байт
                realoc(*(ch_pt_week+k),itemp);
 
            }
            strcpy(*(ch_pt_week+k),static_cast<char*>(String_temp));//копирую содержимое строки
            String_temp.strcat("",true);//очищаю строку и перевыделяю память
            k++;//увеличиваю счётчик элементов для массива ch_pt_week
            
        }
    }
 
}
//вывод на экран дней нидели
void ::String:: show_day_of_week(void)
{
    std::cout<<std::endl;
    for(int i = 0;i<ciDAYOFWEEK;i++)//показать поле 
    {
        std::cout<<*(ch_pt_week+i)<<' ';
        if(i!=0 && i%7 == 0)
        {std::cout<<std::endl;}
 
    }
    std::cout<<std::endl;
}
/*
//сортировка указателей по алфовиту по возрастанию или убыванию
void sort_days_of_week(const direction*const);
 
/**************************************************************************************************************************************/
 
int main(void)
{
    char* v[7]={"Monsday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"} ;
    const int i= 7;
    class String String_val(v,i);
    String_val.show_day_of_week();
    String_val.get_days_of_week();
    String_val.show_day_of_week();
 
 
    system("pause");
return 0;
}