PV913NonTypeTemplateParam

#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;
}

int max(int a, int b)
{
    return a > b ? a : b;
}

void rvalDemo(int& num)
{
    std::cout << "L-Value version!!! " << num << '\n';
}

void rvalDemo(int&& num)
{
    std::cout << "R-Value version!!! " << num << '\n';
}

template <class ElementType, int size>
class StaticArray
{
    ElementType arr[size];
public:
    ElementType& operator[](const int idx) { return arr[idx]; }
    const ElementType& operator[](const int idx)const { return arr[idx]; }
    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';
}

int main()
{
    const int arrSize{ 5 };
    int arr[arrSize]{1,2,3,4,5};

    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{};


    StaticArray<int, 5> sArr1{};
    StaticArray<char, 30> sArr2{};

    printArr(sArr);

    //sArr.length();



    //char* name1{ new char[14]{"Sasha"} };
    //char* name2{ name1 };
    //name1 = nullptr;


    //strcpy_s(name2, 14, name1);

    //delete[] name1;

    //std::cout << name2 << '\n';

    //return 0;

    //DynArray<float> fArr{ 6 };
    //fArr[0] = 36.6;
    //fArr[1] = 37.0;
    //fArr[4] = 38.6;
    //fArr[5] = 42.0;
    //fArr.print();

    //DynArray<int> master{ 6 };
    //master.randomize();
    //master.print();

    //std::cout << '\n';
    //
    //const DynArray<int> arr{ master };
    //
    //////arr.setElem(0, 11);
    ////std::cout << arr.getElem(0) << '\n';
    ////std::cout << arr[0] << '\n';

    ////arr[0] = 12;
    //std::cout << arr[0] << '\n';
    //std::cout << arr.getElem(0) << '\n';
    //std::cout << arr['b'] << '\n';

    //return 0;

}