Lab 17

#include <iostream>
using namespace std;

class MyIntVector {
    //открытые методы класса (открытые функции-члены, интерфейс)
    public:
    //Конструктор инициализирует поля объекта
        MyIntVector (){
            length=0; capacity=1, dataPointer=new int[1]; 
        }
        MyIntVector (const MyIntVector &other){
            //return other;
            length=other.Length();
            capacity=other.Capacity();
            dataPointer=new int[capacity];
            for (int i=0;i<length;i++){
                dataPointer[i]=other[i];
            }
        }
        
        MyIntVector &operator= (const MyIntVector &other){
            length=other.Length();
            capacity=other.Capacity();
            dataPointer=new int[capacity];
            for (int i=0;i<length;i++){
                dataPointer[i]=other.At(i);
            }
            return *this;
        }
        
        const int &At (int index) const {
            return dataPointer [index];
        }
        
        ~MyIntVector (){//Пользовательсий деструктор
            free(dataPointer);
        } 
        void PushBack (int newElement){ //Метод добавляет новый элемент в конец вектора и увеличивает логическую длину на 1
            dataPointer[length]=newElement;
            length++;
            UpCapacity(length+1);
        } 
        int &operator[] (int index) const{ //Оператор получения ссылки на элемент вектора
            return dataPointer[index];
        }
        bool IsEmpty () const{return (length==0?true:false);} //Метод возвращает true, если логический размер равен 0
        int Length () const { return length; }//Метод возвращает логическую длину
        int Capacity () const {return capacity;} //Метод возвращает физическую длину
        
    private:
    //реализация
    //закрытые методы класса (закрытые функции-члены)
        void UpCapacity (int newCapacity){ //Метод увеличения размера блока памяти
            if (newCapacity>capacity) {
                int *newPointer=new int[newCapacity];
                for (int i=0;i<length;i++){
                    newPointer[i]=dataPointer[i];
                }
                dataPointer=newPointer;
            }
        }
        //поля класса (данные-члены)
        int length; //текущее логическое количество элементов вектора (логическая длина)
        int capacity; //количество элементов динамического блока памяти (физическая длина)
        int *dataPointer; //указатель на динамический блок памяти
};

void InputMyIntVector (MyIntVector &inVector, int n){
    for (int i=0;i<n;i++){
        int x; cin>>x;
        inVector.PushBack(x);
    }
}
void OutputMyIntVector (const MyIntVector &outVector){
    const int n=outVector.Length();
    for (int i=0;i<n;i++){
        cout<<outVector[i]<<" ";
    }
    cout<<endl;
}

template <class TypeOfElement>
class MyVector {
    //открытые методы класса (открытые функции-члены, интерфейс)
    public:
    //Конструктор инициализирует поля объекта
        MyVector (){
            length=0; capacity=1, dataPointer=new TypeOfElement[1]; 
        }
        MyVector (const MyIntVector &other){
            length=other.Length();
            capacity=other.Capacity();
            dataPointer=new TypeOfElement[capacity];
            for (int i=0;i<length;i++){
                dataPointer[i]=other[i];
            }
        }
        
        MyVector(TypeOfElement inputArray[], int inLength){
            SetSize(inLength);
            for (int i=0;i<inLength;i++){
                dataPointer[i]=inputArray[i];
            }
        }
        
        MyVector &operator= (const MyIntVector &other){
            //return other;
            if (this == &other) {
                return *this;
             }
            length=other.Length();
            capacity=other.Capacity();
            //cout<<length<<" "<<capacity<<" "<<endl;
            dataPointer=new TypeOfElement[capacity];
            for (int i=0;i<length;i++){
                dataPointer[i]=other[i];
            }
            //OutputMyVector(*this);
            return *this;
        }
        
        const int &At (int index) const {
            return dataPointer [index];
        }
        
        ~MyVector (){//Пользовательсий деструктор
            free(dataPointer);
        } 
        void PushBack (TypeOfElement newElement){ //Метод добавляет новый элемент в конец вектора и увеличивает логическую длину на 1
            dataPointer[length]=newElement;
            length++;
            UpCapacity(length+1);
        } 
        TypeOfElement &operator[] (int index) const{ //Оператор получения ссылки на элемент вектора
            return dataPointer[index];
        }
        bool IsEmpty () const{return (length==0?true:false);} //Метод возвращает true, если логический размер равен 0
        int Length () const { return length; }//Метод возвращает логическую длину
        int Capacity () const {return capacity;} //Метод возвращает физическую длину
        
        void SetSize (int n) {
            length=n;
            UpCapacity(length+1);
        }
        
         MyVector operator+ (const MyVector &left) const {
            MyVector <TypeOfElement> res(left);
            //OutputMyVector(*this);
            //(res);
            int len_old=res.Length();
            //cout<<len_old<<endl;
            res.SetSize(len_old+length);
            //cout<<res.Length()<<endl;
            for (int i=len_old;i<res.Length();i++){
                res[i]=dataPointer[i-len_old];
                //cout<<res[i]<<" ";
            }
            //cout<<endl;
            //OutputMyVector(res);
            return res;
        }
        
    private:
    //реализация
    //закрытые методы класса (закрытые функции-члены)
        void UpCapacity (int newCapacity){ //Метод увеличения размера блока памяти
            if (newCapacity>capacity) {
                TypeOfElement *newPointer=new TypeOfElement[newCapacity];
                for (int i=0;i<length;i++){
                    newPointer[i]=dataPointer[i];
                }
                dataPointer=newPointer;
            }
        }
        //поля класса (данные-члены)
        int length; //текущее логическое количество элементов вектора (логическая длина)
        int capacity; //количество элементов динамического блока памяти (физическая длина)
        TypeOfElement *dataPointer; //указатель на динамический блок памяти
};

template <typename TypeOfElement>
void InputMyVector (MyVector <TypeOfElement> &inVector, int n){
    inVector.SetSize(n);
    for (int i=0;i<n;i++){
        //TypeOfElement x; cin>>x;
        //inVector.PushBack(x);
        cin>>inVector[i];
    }
}
template <typename TypeOfElement>
void OutputMyVector (const MyVector <TypeOfElement> &outVector){
    const int n=outVector.Length();
    for (int i=0;i<n;i++){
        cout<<outVector[i]<<" ";
    }
    cout<<endl;
}


template <class MyType>
void MySwap (MyType &element1, MyType & element2) {
    MyType element3 = element1;
    element1 = element2;
    element2 = element3;
}

/*template <typename TypeOfElement>
MyVector <TypeOfElement> operator+ (const MyVector <TypeOfElement> &first, const MyVector <TypeOfElement> &second) {
            int len_first=first.Length();
            int len_sec=second.Length();
            MyVector <TypeOfElement> res(first);
            //res->SetSize(len_first+len_sec);
            for (int i=len_first;i<len_first+len_sec;i++){
                res.PushBack(second[i]);
            }
            return res;
        }*/

int main() {
    
    /*MyIntVector *v=new MyIntVector();
    int n; cin>>n;
    InputMyIntVector(*v,n);
    
    MyIntVector *w=new MyIntVector();
    w=v;
    //InputMyIntVector(*w,n);
    
    //OutputMyIntVector(*v);
    //OutputMyIntVector(*w);
    
    //cout<<a<<' '<<b<<endl;
    
    char a='a',b='b';
    MySwap(a,b);
    cout<<a<<" "<<b<<endl;*/
    
    int n; cin>>n;
    //MyVector <char> chars,letters,all; 
    MyVector <char> *chars=new MyVector <char> ();
    InputMyVector(*chars,n);
    MyVector <char> *letters=new MyVector <char> ();
    //letters=chars;
    InputMyVector(*letters,n);
    //MySwap(chars,letters);
    MyVector <char> *all = new MyVector <char>(*letters+*chars);
    //OutputMyVector(*all);
    //all=letters;
    //OutputMyVector(*all);
    //OutputMyVector(*chars);
    //OutputMyVector(*letters);
    OutputMyVector(*all);
    
    /*int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    MyVector<int> vec(a, 10);
    OutputMyVector(vec);*/
    
    return 0;
}