PV913AdvancedTemplating

#include <iostream>
#include <chrono>



class String
{
    char* str;
    uint32_t size;
public:
    String(const char* strP)
        : str{ new char[strlen(strP) + 1] }, size{ strlen(strP) }
    {
        strcpy_s(str, size + 1, strP);
    };

    ~String() { delete[] str; };

    String& operator=(const char* strP)
    {
        delete[] str;
        str = new char[strlen(strP) + 1];
        size = strlen(strP);
        strcpy_s(str, size + 1, strP);
        return *this;
    };

    friend std::ostream& operator<<(std::ostream& out, const String& rhs)
    {
        out << rhs.str;
        return out;
    }
};


class Number
{
    int num;
public:
    Number(int numP) : num{ numP } { std::cout << "Number constructed for " << this << " with value " << num << '\n'; }
    Number() : Number{ 0 } {};
    Number& operator=(const int rhs) { num = rhs; std::cout << "Number assigned for " << this << " with value " << num << '\n'; return *this; }
    friend std::ostream& operator<<(std::ostream& out, const Number& rhs)
    {
        out << "Number: " << rhs.num;
        return out;
    }
    ~Number() { std::cout << "Number destructed for " << this << " with value " << num << '\n'; };
};

class TestNum
{
    Number num;
    int _initNum(int max) { return rand() % max; };
public:
    TestNum() { num = _initNum(11);  std::cout << "TestNum constructed for " << this << '\n'; };
    ~TestNum() { std::cout << "TestNum destructed for " << this << '\n'; }
};

template <class ElementType>
class DynArray
{
    ElementType* arr;
    int size;
public:
    DynArray(int pSize) : arr{ new ElementType[pSize] {} }, size{ pSize } {std::cout << "DynArr constructed for " << size << " elements, for " << this << '\n'; };
    DynArray() : DynArray(5) {};
    //COPY
    DynArray(const DynArray& obj);
    DynArray& operator=(const DynArray& obj);
    //MOVE
    DynArray(DynArray&& obj);
    DynArray& operator=(DynArray&& obj);

    const ElementType& getElem(int idx) const { return arr[idx]; };
    void setElem(int idx, const ElementType& val) { arr[idx] = val; };

    ElementType& operator[](const int idx) { return arr[idx]; };
    const ElementType& operator[](const int idx) const { return arr[idx]; };

    ElementType& operator[](const char idx) { return arr[toupper(idx) - 'A']; };
    const ElementType& operator[](const char idx) const { return arr[toupper(idx) - 'A']; };

    void print();
    void randomize();
    ~DynArray()
    {
        if (arr)
        {
            std::cout << "this->arr = " << this->arr << '\n';
            delete[] arr;
        };
        std::cout << "DynArr destructed for " << size << " elements, for " << this << '\n';
    };
};

template <class ElementType>
void DynArray<ElementType>::print()
{
    for (int i{ 0 }; i < size and arr; ++i)
    {
        std::cout << arr[i] << ' ';
    }
    std::cout << '\n';
}

template <class ElementType>
void DynArray<ElementType>::randomize()
{
    for (int i{ 0 }; i < size; ++i)
    {
        arr[i] = rand() % 10;
    }
}


template <class ElementType>
DynArray<ElementType>::DynArray(const DynArray<ElementType>& obj)
    : arr{ new ElementType[obj.size] {} }, size{ obj.size }
{
    for (int i{ 0 }; i < size; ++i)
    {
        arr[i] = obj.arr[i];
    };

    std::cout << "DynArr COPY constructed for " << size << " elements, for " << this << '\n';
};


template <class ElementType>
DynArray<ElementType>::DynArray(DynArray<ElementType>&& obj)
    : arr{ obj.arr }, size{ obj.size }
{
    obj.arr = nullptr;
    obj.size = 0;

    std::cout << "DynArr MOVE constructed for " << size << " elements, for " << this << '\n';
};

template <class ElementType>
DynArray<ElementType>& DynArray<ElementType>::operator=(DynArray<ElementType>&& obj)
{
    if (this == &obj)
    {
        std::cout << "DynArr self assign in MOVE PREVENTED! for " << this << '\n';
        return *this;
    }

    delete[] arr;

    arr = obj.arr;
    size = obj.size;

    obj.arr = nullptr;
    obj.size = 0;

    std::cout << "DynArr MOVE assigned for " << size << " elements, for " << this << '\n';
    return *this;
};

template <class ElementType>
void printDynArrEl(DynArray<ElementType>& arr, int idx)
{
    std::cout << arr.getElem(idx) << ' ';
}

template <class ElementType>
DynArray<ElementType> mkArray(int size)
{
    DynArray<ElementType> arrInternal{ size };
    arrInternal.randomize();
    return arrInternal;
}

template <class ElementType, int size>
class StaticArray
{
    ElementType arr[size]{};
public:
    StaticArray() = default;
    explicit StaticArray(const std::initializer_list<ElementType>& param)
    {
        int i{ 0 };

        for (const auto& elem : param)
        {
            if (i < size)
            {
                arr[i++] = elem;
            }
            else
            {
                std::cout << "Error! Overinitialisation prevented! :)\n";
                break;
            }
        }
    };

    void operator=(const std::initializer_list<ElementType>& param)
    {
        int i{ 0 };
        int shift{ -1 };
        for (const auto& elem : param)
        {
            if (shift == -1)
            {
                shift = elem;
                continue;
            }

            if (i+shift < size)
            {
                arr[shift + i++] = elem;
            }
            else
            {
                std::cout << "Error! Overassigment prevented! :)\n";
                break;
            }
        }
    };
    ElementType& operator[](const int idx) { return arr[idx]; }
    const ElementType& operator[](const int idx)const { return arr[idx]; }
    const ElementType* begin() { return arr; };
    const ElementType* end() { return arr + size; };
    ElementType& at(const int idx)
    {
        if ((idx >= 0) and (idx < size))
        {
            return arr[idx];
        }
        std::cout << "Index " << idx << " is out of range 0.." << size;
        exit(0);
    };

    int length() const { return size; };
    ElementType* getRawData() { return arr; };
};

//template <typename T>
//void printArr(T* arr, int size)
//{
//    for (int i{ 0 }; i < size; ++i)
//    {
//        std::cout << arr[i] << ' ';
//    }
//    std::cout << '\n';
//}

template <typename T, int size>
void printArr(T* arr)
{
    for (int i{ 0 }; i < size; ++i)
    {
        std::cout << arr[i] << ' ';
    }
    std::cout << '\n';
}

template <typename T, int size>
void printArr(const StaticArray<T, size>& arr)
{
    for (int i{ 0 }; i < arr.length(); ++i)
    {
        std::cout << arr[i] << ' ';
    }
    std::cout << '\n';
}

template <int size>
void printArr(const StaticArray<char, size>& arr)
{
    for (int i{ 0 }; i < arr.length(); ++i)
    {
        std::cout << arr[i];
    }
    std::cout << '\n';
}

template <typename T>
void printArr(const StaticArray<T, 3>& arr)
{
    std::cout << "Three element array! Small one!\n";
    for (int i{ 0 }; i < arr.length(); ++i)
    {
        std::cout << arr[i] << '\t';
    }
    std::cout << '\n';
}

template <class T>
T max(T a, T b) { return a > b ? a : b; };

//std::initializer_list<int>

int main()
{
    const int arrSize{ 5 };
    int arr[arrSize]{ 1,2,3,4,5 };
    //for (auto& a : arr)
    //{
    //    std::cout << ++a << '\t';
    //}
    //std::cout << '\n';

    /*const auto begin{ arr };
    const auto end{ arr + arrSize };
    for (auto elem{begin}; elem < end; ++elem)
    {
        std::cout << *elem << ' ';
    }
    return 0;*/
    //for (const auto& a : arr)
    //{
    //    std::cout << a << '\t';
    //}
    //std::cout << '\n';
    //return 0;

    const int arrSizeF{ 8 };
    float arrFloat[arrSizeF]{ 0.1,0.2, 0.3,0.4,0.5,0.6, 0.7, 0.8 };

    printArr<int,arrSize>(arr);
    printArr<float, arrSizeF>(arrFloat);

    StaticArray<int, arrSize> sArr{12,24,63,74};
    //StaticArray<int, arrSize> sArr;

    printArr(sArr);

    std::cout << "\nRange-based for goes here...\n";

    for (const auto& elem : sArr)
    {
        std::cout << elem << ' ';
    }

    std::cout << "\nMagic goes here...\n";
    sArr = { 2, 99,910,911 };


    for (const auto& elem : sArr)
    {
        std::cout << elem << ' ';
    }

    std::cout << '\n';

    const int strSize{ 14 };
    StaticArray<char, strSize> str{ 'H', 'e', 'l', 'l', 'o', ' ', 'w','o','r','l','d','!' };
    printArr(str);

    const int strSize1{ 3 };
    StaticArray<char, strSize1> str1{ 'A', 'B', 'C' };
    printArr<char>(str1);

    StaticArray<int, strSize1> arr1{ 88,99,77 };
    printArr(arr1);

    //sArr.length();

}