Lab_8/8 var (IIl semester)

//Lab_8_8var
#include "stdafx.h"
#include <iostream>
#include <ctime>

using namespace std;
//8. Задан массив из k чисел. Преобразовать массив следующим образом:
//все положительные элементы массива перенести в начало, а все остальные – в конец,
//сохранив исходное взаимное расположение как среди отрицательных, так и среди положительных элементов.
template <typename T> class Element {
public:
    T elem;
    Element() {}
    Element(T e)
    {
        elem = e;
    }
    template <typename T> T operator *(T &e)
    {
        return elem * e.elem;
    }
    template <typename T> T operator +=(T &e)
    {
        return elem += e.elem;
    }
    operator T()
    {
        return elem;
    }
    Element(const Element &base)
    {
        elem = base.elem;
    }
};
//явное инстанцирование шаблона функции
template int* TransformationDefaultType(int*, int);
int* TransformationDefaultType(int* arrayA, int size)
{
    int *positive = new int[size];
    int *negative = new int[size];
    int countP = 0, countN = 0;
    for (int i = 0; i < size; i++)
        if (arrayA[i] > 0)
        {
            positive[countP] = arrayA[i];
            countP++;
        }
        else
        {
            negative[countN] = arrayA[i];
            countN++;
        }
    for (int i = 0; i < countP; i++)
        arrayA[i] = positive[i];
    for (int i = countP; i < size; i++)
        arrayA[i] = negative[i - countP];
    for (int i = 0; i < size; i++)
    {
        cout << arrayA[i] << " ";
    }
    cout << "\nint";
    return arrayA;
}
template double* TransformationDefaultType(double*, int);
double* TransformationDefaultType(double* arrayA, int size)
{
    double *positive = new double[size];
    double *negative = new double[size];
    int countP = 0, countN = 0;
    for (int i = 0; i < size; i++)
        if (arrayA[i] > 0)
        {
            positive[countP] = arrayA[i];
            countP++;
        }
        else
        {
            negative[countN] = arrayA[i];
            countN++;
        }
    for (int i = 0; i < countP; i++)
        arrayA[i] = positive[i];
    for (int i = countP; i < size; i++)
        arrayA[i] = negative[i - countP];
    for (int i = 0; i < size; i++)
    {
        cout << arrayA[i] << " ";
    }
    cout << "\ndouble";
    return arrayA;
}
template float* TransformationDefaultType(float*, int);
float* TransformationDefaultType(float* arrayA, int size)
{
    float *positive = new float[size];
    float *negative = new float[size];
    int countP = 0, countN = 0;
    for (int i = 0; i < size; i++)
        if (arrayA[i] > 0)
        {
            positive[countP] = arrayA[i];
            countP++;
        }
        else
        {
            negative[countN] = arrayA[i];
            countN++;
        }
    for (int i = 0; i < countP; i++)
        arrayA[i] = positive[i];
    for (int i = countP; i < size; i++)
        arrayA[i] = negative[i - countP];
    for (int i = 0; i < size; i++)
    {
        cout << arrayA[i] << " ";
    }
    cout << "\nfloat";
    return arrayA;
}
template <typename T> T* TransformationDefaultType(T* arrayA, int size); //шаблон функции для стандартных типов данных (int, float, double)
template <typename T> T* TransformationDefaultType(T* arrayA, int size)
{
    T *positive = new T[size];
    T *negative = new T[size];
    int countP = 0, countN = 0;
    for (int i = 0; i < size; i++)
        if (arrayA[i] > 0)
        {
            positive[countP] = arrayA[i];
            countP++;
        }
        else
        {
            negative[countN] = arrayA[i];
            countN++;
        }
    for (int i = 0; i < countP; i++)
        arrayA[i] = positive[i];
    for (int i = countP; i < size; i++)
        arrayA[i] = negative[i - countP];
    for (int i = 0; i < size; i++)
    {
        cout << arrayA[i] << " ";
    }
    return arrayA;
}



template <class T> T* TransformationAbstractType(T arrayA[], int size); //шаблон функции для абстрактного типа данных
template <class T> T* TransformationAbstractType(T arrayA[], int size)
{
    T *positive = new T[size];
    T *negative = new T[size];
    int countP = 0, countN = 0;
    for (int i = 0; i < size; i++)
        if (arrayA[i] > 0)
        {
            positive[countP] = arrayA[i];
            countP++;
        }
        else
        {
            negative[countN] = arrayA[i];
            countN++;
        }
    for (int i = 0; i < countP; i++)
        arrayA[i] = positive[i];
    for (int i = countP; i < size; i++)
        arrayA[i] = negative[i - countP];
    for (int i = 0; i < size; i++)
    {
        cout << arrayA[i] << " ";
    }
    return arrayA;
}

int main()
{
    int size = 0;
    srand(time(NULL));
    cout << "Enter size arrays: ";
    cin >> size;
    cout << "template <typename T>" << endl;
    float *arrayA = new float[size];
    cout << "Array A: " << endl;
    for (int i = 0; i < size; i++)
    {
        arrayA[i] = (rand() % (20 - -10 + 1) + -10)/2.13;
        cout << arrayA[i] << " ";
    }
    cout << "\nTransformationDefaultType A:" << endl;
    TransformationDefaultType(arrayA, size);
    for (int i = 0; i < size; i++)
    {
        cout << arrayA[i] << " ";
    }
    cout << "\ntemplate <class T>" << endl;
    Element<double> *AbstractArrayA = new Element<double>[size];
    cout << "\nArray A(AbstractType) double: " << endl;
    for (int i = 0; i < size; i++)
    {
        AbstractArrayA[i].elem = (rand() % (20 - -10 + 1) + -10) / 2.13;
        cout << AbstractArrayA[i].elem << " ";
    }
    cout << "\nTransformationAbstractType A:" << endl;
    TransformationAbstractType(AbstractArrayA, size);
    Element<int> *AbstractArrayAInt = new Element<int>[size];
    cout << "\nArray A(AbstractType) int: " << endl;
    for (int i = 0; i < size; i++)
    {
        AbstractArrayAInt[i].elem = (rand() % (20 - -10 + 1) + -10);
        cout << AbstractArrayAInt[i].elem << " ";
    }
    cout << "\nTransformationAbstractType A:" << endl;
    TransformationAbstractType(AbstractArrayAInt, size);
    system("pause");
}