How to declare a constructor in reversed class?

Question

I wonder how to declare the reference to a constructor to a reversed class, i.e. I have a class say Game and it has a constructor at a certain address.

It is declared like this:

game.h

namespace gladius {
    struct Game {
        //virtual int __thiscall main(gladius::Game* thisptr, int param_1, char** param_2, char** param_3);

        using GameConstructor = Game * (__fastcall*) (Game* thisptr);
        GameConstructor gameConstructor;

..........

}

game.cpp

namespace gladius {
    static std::array<Game, 1> functions = { {
                Game{

            (Game::GameConstructor)(AddressHelper::getInstance().GetBaseAddress() + 0x331b0 / (2 * sizeof(DWORD))),

Now let's imagine I want an instance of the Game object. How do I get one as something like this

Game gameObj = gameConstructor; 

is not going to work as gameObj and gameConstructor have different type. Without reversing the constructor is there any way to call it (by address) and assign the reversed class instance to it?

And

 namespace gladius {
        struct Game {
              using Game = Game * (__fastcall*) (Game* thisptr);
              Game gameConstructor;

doesn't work as a declaration as you can't declare type the same as the type of the class / structure and I don't know how to modify the above to keep it as a reference to the addressed method rather than a fully reversed function.

Basically the question is, how to do

Game objInst = new Game();

where new Game(); points to existing Game constructor (accessible by address offset)?

Answer 1

Here is the solution:

The constructor can be called like this:

    gladius::GameStruct* thisptr = (gladius::GameStruct*)malloc(sizeof(gladius::GameStruct));
    gladius::get().gameConstructor(thisptr);

where sizeof(GameStruct) must match the size of the original constructor. In my case the Game structure should be re-written to have something like:

struct GameStruct : Game{
        
        DWORD_PTR* unknownPtrA = 0;

        DWORD_PTR* unknownPtrB = 0;

        DWORD_PTR* unknownPtrC = 0;

        DWORD_PTR* unknownPtrD = 0;

        DWORD_PTR* guiObjPtr = 0;

        DWORD_PTR* unknownPtrE = 0;

        DWORD_PTR* unknownPtrF = 0;

        DWORD_PTR* unknownPtrG = 0;

        DWORD_PTR* unknownPtrH = 0;

        DWORD_PTR* unknownPtrI = 0;

        DWORD_PTR* unknownPtrJ = 0;

    };

to bring the pointers in constructor outside of the Game struct. This way it matches the original constructor in what it does and in size (i.e. 11 members 8 bytes each = 88 bytes of size)

Or / and the pointers to the functions should be placed inside the standard C++ functions and be called from there as that way they won't occupy the additional memory space which needs to be allocated.