PV913OverloadFinish!

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

class DynArray
{
    int* arr;
    int size;
public:
    DynArray(int pSize) : arr{ new int[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);

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

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

    //arr["Apple"] = 25;

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

    //void operator()() { std::cout << "Boom!\n"; delete[] arr; };
    //void operator()()const { std::cout << "Boom!\n"; delete[] arr; };

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

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

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

DynArray::DynArray(const DynArray& obj)
    : arr{ new int[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';
};



DynArray::DynArray(DynArray&& obj)
    : arr{ obj.arr }, size{ obj.size }
{
    obj.arr = nullptr;
    obj.size = 0;

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

DynArray& DynArray::operator=(DynArray&& 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;
};

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


DynArray mkArray(int size)
{
    DynArray 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';
}

class Accumulator
{
    int val;
public:
    explicit Accumulator(int startVal = 0) : val{ startVal } {};
    //Accumulator() : Accumulator{ 0 } {};
    int operator()() { return val; };
    int operator()(const int delta) { return (val += delta); };
};

int simpleAcc(const int delta=0)
{
    static int val{0};
    return val += delta;
}

int main()
{

    Accumulator acc{};
    std::cout << "Current acc value is: " << acc() << '\n';
    std::cout << "Current acc value is: " << acc(4) << '\n';
    std::cout << "Current acc value is: " << acc(4) << '\n';
    std::cout << "Current acc value is: " << acc(-4) << '\n';

    std::cout << "###\n";

    std::cout << "Current simpleAcc value is: " << simpleAcc() << '\n';
    std::cout << "Current simpleAcc value is: " << simpleAcc(4) << '\n';
    std::cout << "Current simpleAcc value is: " << simpleAcc(4) << '\n';
    std::cout << "Current simpleAcc value is: " << simpleAcc(-4) << '\n';
    return 0;

    DynArray master{ 6 };
    master.randomize();
    master.print();

    std::cout << '\n';

    const DynArray 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;

    /*l - value
    r - value*/

    //int num1{ 10 };
    //int num2{ 23 };

    //rvalDemo(num1);

    //rvalDemo(std::move(num1));

    ////int& numRef{ max(num1,num2) };

    //int&& numRvalRef{ max(num1,num2) };

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

    //numRvalRef = 789;

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



    //numRef = 5555;

    //max(num1, num2) = 555;


      /*  int x{34};
        int* ptr = new int{ 444 };

        *ptr

        x = 56;

        int y{};

        y = x;*/


        //DynArray arrExternal{};

        //arrExternal = mkArray(7);
        ////arrExternal = DynArray{7};

        //arrExternal.print();

    DynArray arr1{ 7 };
    arr1.randomize();
    arr1.print();

    std::cout << "Create copy of arr1 in arr2!\n";
    DynArray arr2{ std::move(arr1) };
    arr2.print();

    std::cout << "Arr1 still alive and fully functional!\n";
    arr1.print();
    arr1 = DynArray{ 4 };
    arr1.print();


    //String str{ "Initial string!" };
    //std::cout << str << '\n';
    //str = "Some new string";
    //std::cout << str << '\n';


    /*srand(time(nullptr));
    TestNum tn;*/

    //Number n{333};
    //n = 42;
    //std::cout << n << '\n';
     //int x{ 42 };
    //x = x;

    //std::cout << "X = " << x << '\n';
    //return 0;
/*
    std::cout << "arr1 creation\n";
    DynArray arr1{8};
    arr1.print();
    arr1.randomize();
    arr1.print();
    std::cout << "arr2 creation\n";
    DynArray arr2{};
    arr2.randomize();
    arr2.print();
    arr2 = arr1; // { arr2.arr = arr1.arr; arr2.size = arr1.size; }
    arr2.print();

*/

//DynArray arr{};
//arr = mkArray(8);
//arr.print();

}