Xemectrum

Code: Select all

//For the allocator and deallocator
int LowestIndex = 0;
int Stack = 0;

//For the OOP thingy, I guess =/
int IntegerArray [8190];

int GetAllocation () {
     int This = LowestIndex;

     if (This==0) {
        Stack=Stack+1;
        This=Stack;
     }

     if (This>8190) {
         return 0;
     }

     return This;
}

void DeAllocate(Integer) {
    if (Integer != null) {
        LowestIndex = Integer;
    }
}

void main () {
    int Loop = 1;
    int CurrentAllocation;    

    srand(time(0));

    while (Loop < 5) {
            CurrentAllocation= GetAllocation();
            IntegerArray[CurrentAllocation] = Loop;
            if (rand() % 2 == 1) {
                DeAllocate(CurrentAllocation);
            }

    Loop = Loop + 1;
    }
    
    /*What it'll do is allocate an instance of a struct, I guess =/
       Then, there are a few possible outcomes, Let us say the following happens:
       01) Loop Starts
       02) CurrentAllocation is set to "GetAllocation()"
       03) GetAllocation() set 'This' equal to 0 because LowestIndex is 0 right now
       04) This is equal to 0, so, Stack becomes 'Stack + 1' = 1, I don't want to allocate instance 0, lol
       05) GetAllocation() returns the value of '1'
       06) We set IntegerArray[1], a supposed struct member, to the current loop, 1
       07) We randomize a number, it's != 1, so we do not deallocate.
       08) Loop = Loop + 1 = 2
       09) CurrentAllocation is set to "GetAllocation()"
       10) GetAllocation() set 'This' equal to 0 because LowestIndex is 0 right now
       11) This is equal to 0, so, Stack becomes 'Stack + 1' = 2
       12) GetAllocation() returns the value of '2'
       13) We set IntegerArray[2], a supposed struct member, to the current loop, 2
       14) We randomize a number, it's != 1, so we do not deallocate.
       15) Loop = Loop + 1 = 3
       09) CurrentAllocation is set to "GetAllocation()"
       10) GetAllocation() set 'This' equal to 0 because LowestIndex is 0 right now
       11) This is equal to 0, so, Stack becomes 'Stack + 1' = 3
       12) GetAllocation() returns the value of '3'
       13) We set IntegerArray[3], a supposed struct member, to the current loop, 3
       14) We randomize a number, it's == 1, so we deallocate.
       15) We call DeAllocate(CurrentAllocation)
       16) DeAllocate checks if the given integer is == null
       17) It is not, so it sets LowestIndex to '3'
       18) Loop = Loop + 1 = 4
       19) CurrentAllocation is set to "GetAllocation()"
       20) GetAllocation() set 'This' equal to 3 because LowestIndex is 3 right now
       22) GetAllocation() returns the value of '3'
       23) We set IntegerArray[3], a supposed struct member, to the current loop, 4
       24) We randomize a number, it's == 1, so we deallocate.
       25) We call DeAllocate(CurrentAllocation)
       26) DeAllocate checks if the given integer is == null
       27) It is not, so it sets LowestIndex to '3'
       28) Loop = Loop + 1 = 5
       29) Loop is == 5 and is not smaller than it, so we end the loop there.

Let us take a look at the end results of out IntegerArray:
IntegerArray[1] = 1
IntegerArray[2] = 2
IntegerArray[3] = 4 <--- And not 3 XD

Erm.. Something like that? o.0

*/

}