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;

}