//: C13:GlobalOperatorNew.cpp
#include <cstdio>
#include <cstdlib>
#include <iostream>

const int ElementCount = 100;

unsigned char  store[1002550];

bool  busyStore[ElementCount] = { false };
unsigned char  storeArr[2550];
bool  busyStoreArr[10000] = { false };

class myClss {
    int x;
    /*int y;
    int z;*/
    static int Next;
public:
    myClss() : x(555+Next++){ std::cout << "constr" << std::endl; };
    myClss(int x1) : x(x1){}
    ~myClss() {}
    void* operator new (size_t sz) {
        //std::cout << "here" << std::endl;
        int coord_not_busy = 0;
        for (; busyStore[coord_not_busy]; coord_not_busy++);
        busyStore[coord_not_busy] = true;
        return store + coord_not_busy * sizeof(myClss);
    }

    void operator delete (void* o) {
        unsigned long X = (unsigned long)o - (unsigned long)store;
        busyStore[((unsigned long)o - (unsigned long)store) / sizeof(x)] = false;
        //store+ X = 0;
    }

    void* operator new[](const size_t qty)  {
        int coord_not_busy = 0;
        int byteqtystringFree = 0;
        int x = 0;
        while (x < ElementCount) {
            for (; busyStore[coord_not_busy]; coord_not_busy++); //найдем первый незанятый элемент
            for (x = coord_not_busy, byteqtystringFree = 1; !busyStore[x] && byteqtystringFree < qty; x++, byteqtystringFree++);
            if (!busyStore[x] && byteqtystringFree == qty)

                return store + coord_not_busy  * sizeof(myClss);
            else coord_not_busy = x;
        }
        return 0;
    }

    void printValue() { std::cout << x << std::endl; }


};
int myClss::Next = 0;
int main() {
    myClss* hhX1 = new myClss(111);
    myClss* hhX2 = new myClss(222);
   
    myClss* hhX3 = new myClss[2];
    hhX1->printValue();
    hhX2->printValue();
    hhX3[0].printValue();
    hhX3[1].printValue();
}

int* x = new int[1];
x[0] = 5;
unsigned char* xc = (unsigned char*)x;
std::cout << (int)*(xc) << std::endl;
std::cout<<(int)*(xc - 1)<<std::endl;
std::cout << (int)*(xc - 2) << std::endl;
std::cout << (int)*(xc - 3) << std::endl;
std::cout << (int)*(xc - 4) << std::endl;

#include <stdio.h>

void* operator new[](size_t count)
{
   printf("new[](%u)\n", count);
   return (void*)12345;
}

int main()
{
   int* arr = new int[2];
}

#include <iostream>
unsigned char storage[50];
class myCls {
     int iii;
     static int Next;
    public:
        myCls() : iii(Next++) {};
        ~myCls() {};
        void* operator new[](size_t sz) {

            return storage ;
        }

};
int myCls::Next = 1;
int main()
{
    myCls *kk = new myCls[4];
    for (size_t i = 0; i < 50; i++)
        std::cout <<"storage["<<i<<"]" << (int)storage[i] << std::endl;
    
}