初始化结构指针

-1

我在初始化结构指针时遇到了一些问题。初始化结构指针

struct Hook{ 
    DWORD64 Address; 
    vector<BYTE> OriginalBytes; 
    vector<BYTE> HookBytes; 
    SIZE_T length; 
    bool Initialized; 
}; 
Hook *hFuncHook; 
void InitializeHookInfo(Hook* hook, DWORD64 address, SIZE_T size){ 
    hook = new Hook; 
    hook->Address = address; 
    hook->OriginalBytes = GetAOB(address, size); 
    hook->HookBytes.reserve(size); 
    hook->length = size; 
    hook->Initialized = false; 
} 
void EndHookInfoInit(Hook* hook, DWORD64 address, SIZE_T size){ 
    printf("Hook size: %i\n", sizeof(hook)); //returns 8 
    hook->HookBytes = GetAOB(address, size);//Crash right there 
    hook->Initialized = true; 
} 

void InitMyHooks(){ 
    InitializeHookInfo(hFuncHook, mBase + 0xA100FC, 6); 
    HookFunction(...); 
    EndHookInfoInit(hFuncHook, mBase + 0xA100FC, 6); 
}

我不明白为什么这个崩溃。 InitializeHookInfo部分不会导致任何问题，但EndHookInfoInit只是崩溃。

卸下hook->HookBytes = GetAOB(...);也导致系统崩溃

来源

2016-09-24 Dipps03

提示：通过引用 – SomeWittyUsername

什么语言传递参数的这段代码应该是在？它看起来像C，但拼错了“malloc”？ – kfsone

@kfsone'vector '在一个结构定义里面在C中是非法的 –

的指针（T*）无非，其值是在T的实例的存储器被视为地址的变量更复杂的，除非它包含的nullptr值。

将变量传递给C++函数的默认行为是按值传递的。

int f(int i) { // i is local copy of source parameter 
    i = 2; // only modifies local copy 
}

这是没有什么不同，当你传递一个指针

int f(T* p) { 
    p = new T; 
}

你的代码是由值采用指针：

void InitializeHookInfo(Hook* hook, DWORD64 address, SIZE_T size);

所以这行代码：

InitializeHookInfo(hFuncHook, mBase + 0xA100FC, 6);

复制值hFuncHook的到函数的第一参数槽，内部InitializeHookInfo

void InitializeHookInfo(Hook* hook, DWORD64 address, SIZE_T size) { 
    hook = new Hook;

这种分配一个新的钩和地址分配给本地变量。

您应该考虑：

a。从你的功能返回指针

Hook* InitializeHookInfo(DWORD64 address, SIZE_T size) { 
    Hook* hook = new Hook; 
    // ... 
    return hook; 
}

b。通过地址取指针

void InitializeHookInfo(Hook** hook, DWORD64 address, SIZE_T size) { 
    *hook = new Hook;

c。参照带指针（略讨厌的，因为它是不透明的）

void InitializeHookInfo(Hook*& hook, DWORD64 address, SIZE_T size) { 
    hook = new Hook; // affects source parameter

或者，你可能更考虑使用成员函数

struct Hook{ 
    DWORD64 Address { 0 }; 
    vector<BYTE> OriginalBytes; 
    vector<BYTE> HookBytes; 
    SIZE_T length { 0 }; 
    bool Initialized { false }; 

    Hook() {} 

    Hook(DWORD64 address, SIZE_T size) 
     : Address { address } 
     , OriginalBytes { GetAOB(address, size) } 
     , length(size) 
    { 
     HookBytes.reserve(size); 
    } 

    void EndInit(DWORD64 address, SIZE_T size) 
    { 
     std::cout << "Hook size: " << sizeof(*this) << "\n"; 
     HookBytes = GetAOB(address, size); // didn't we already do this? 
     Initialized = true; 
    } 
}; 

std::unique_ptr<Hook> hFuncHook; 

void InitMyHooks() 
{ 
    hFuncHook = std::make_unique<Hook>(mBase + 0xA100FC, 6); 
    HookFunction(hFuncHook.get()); 
    hFuncHook->EndInit(mBase + 0xA100FC, 6); 
}

最后，

printf("Hook size: %i\n", sizeof(hook)); //returns 8

这是因为hook是一个指针，您正在打印

printf("Hook size: %i\n", sizeof(Hook*)); //returns 8

你可能想

printf("Hook size: %i\n", sizeof(*hook)); //returns 8

来源

2016-09-25 00:46:38 kfsone

初始化结构指针

回答

相关问题