Should I finish beginner stage before hacking?

typedef struct
{
   int x, y, w, h;
   float* CalcDimensions();
} cScreenMatrix;

float* cScreenMatrix::CalcDimensions( int V )
{
   float Screen[4] = { 0.f };
   if( !this->x || !this->y || !this->w || !this->z )
         Screen = { -1.f };
   else
   {
      this->x *= GetX();
      this->y += ( V >> GetY() );
      this->w += this->x;
      this->h /= ( this->w | GetH() );
    }
    for( ; this->x > V; this->x++ )
         Screen[1] += x;
    memcpy( (PVOID)&Screen, (PVOID)&this->x, sizeof(cScreenMatrix) );
    return &Screen;
}

cScreenMatrix* x = (cScreenMatrix*)OFF_SCREEN;

typedef struct // Typedefining a structure to be used as an object
{
   int x, y, w, h; // declaring variables - Yep
   float* CalcDimensions( int V ); // function - Yep
} cScreenMatrix; // The above structure will now be known as an object "cScreenMatrix". This is more like a outline of an object rather than the object itself. You can only use this to create objects

float* cScreenMatrix::CalcDimensions( int V ) // the function itself - Yep
{
   float Screen[4] = { 0.f }; // Declares a float array (4-float stored one after another in the memory) and initialize them all to 0.0f
   if( !this->x || !this->y || !this->w || !this->z ) // Checks the variables in the said object is 0. The "this->" means the variables in the current object
         Screen = { -1.f }; // Assigns all the variables in Screen array to -1.
   else
   {
      this->x *= GetX(); // x = x * getx() - Yep
      this->y += ( V >> GetY() ); // y = y + (v >> gety()) - Yep
      this->w += this->x; // Takes the object's x value and adds it to it's w value
      this->h /= ( this->w | GetH() ); // Takes the object's w value and does a bitwise OR (Yes, C language here, look up bitwise operations) against the value returned by GetH()
    }
    for( ; this->x > V; this->x++ ) // if x is less than v, then x goes up 1 - Yep but it increases the object's X value
         Screen[1] += x; // Second variable in Screen array is increased by the value of x
    memcpy( (PVOID)&Screen, (PVOID)&this->x, sizeof(cScreenMatrix) ); // Copies the values of the screen array to the object's memory location
    return &Screen; // This returns the address of the Screen array in the memory.
}

cScreenMatrix* x = (cScreenMatrix*)OFF_SCREEN; // Creates a new object of cScreenMatrix called X and maps it's memory location to the value OFF_SCREEN

//Some function
...
    float* OffsetOfCalculatedScreenDimensions = x->CalcDimensions(1);
//Now x contains the values of OffsetOfCalculatedScreenDimensions in it's structure