c++ - 转换为 ctypes 但我不知道这些函数在做什么

Question

我想知道这里的这个函数是做什么的:

  ralloc_t(HWND hwnd) : proc_(0)
  {
    DWORD pid = 0;
    if (!GetWindowThreadProcessId(hwnd, &pid)) {
      throw exception("dang, no dice");
    }
    proc_ = OpenProcess(
        PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION, FALSE, pid);
    if (!proc_) {
      throw exception("no open for me!");
    }
  }
  ~ralloc_t()
  {
    buffers_t::reverse_iterator i = buffers_.rbegin(), e = buffers_.rend();
    for (; i != e; ++i) {
      free(i->first);
    }
  }

老实说，我不知道函数从哪里开始，从哪里结束，也不知道它是否返回任何东西。

完整代码如下。我有了一个不错的开始，因为我已经将下面使用的所有 winapi 函数都转换为 js-ctypes。这是我目前所拥有的:https://gist.github.com/Noitidart/f691ab9a750f24be346f

#include <windows.h>
#include <commctrl.h>

#include <iostream>
#include <cstdio>
#include <stdexcept>
#include <map>

using namespace std;

/**
 * Allocate/read/write remote process memory.
 * The implementation is pretty crappy, as it isn't intelligent at all:
 * It always allocates at least a full page per allocation :(
 * Do something more clever in production!
 * Also, type safety and convenience are pretty lacking.
 * But again, this is test code, so it sucks!
 */
class ralloc_t
{
public:
  ralloc_t(HWND hwnd) : proc_(0)
  {
    DWORD pid = 0;
    if (!GetWindowThreadProcessId(hwnd, &pid)) {
      throw exception("dang, no dice");
    }
    proc_ = OpenProcess(
        PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION, FALSE, pid);
    if (!proc_) {
      throw exception("no open for me!");
    }
  }
  ~ralloc_t()
  {
    buffers_t::reverse_iterator i = buffers_.rbegin(), e = buffers_.rend();
    for (; i != e; ++i) {
      free(i->first);
    }
  }
  void* alloc(size_t size)
  {
    void* rv = VirtualAllocEx(
        proc_, 0, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (!rv) {
      throw bad_alloc();
    }
    buffers_.insert(make_pair(rv, size));
    return rv;
  }
  template <typename T>
  T* create(size_t elems = 1)
  {
    return (T*)alloc(elems * sizeof(T));
  }

  void free(void* p)
  {
    buffers_t::iterator i = buffers_.find(p);
    if (i == buffers_.end()) {
      throw exception("invalid buffer");
    }
    VirtualFreeEx(proc_, i->first, i->second, MEM_RELEASE);
    buffers_.erase(i);
  }

  void read(void* remote, void* local)
  {
    buffers_t::iterator i = buffers_.find(remote);
    if (i == buffers_.end()) {
      throw exception("invalid remote read buffer");
    }
    if (!ReadProcessMemory(proc_, i->first, local, i->second, 0)) {
      throw exception("failed to read remote buffer");
    }
  }

  void write(void* remote, const void* local)
  {
    buffers_t::iterator i = buffers_.find(remote);
    if (i == buffers_.end()) {
      throw exception("invalid remote write buffer");
    }
    if (!WriteProcessMemory(proc_, i->first, local, i->second, 0)) {
      throw exception("failed to write remote buffer");
    }
  }

private:
  typedef map<void*, size_t> buffers_t;
  buffers_t buffers_;
  HANDLE proc_;
};

int main()
{
  typedef HWND(WINAPI * GetTaskmanWindowPtr)();
  try
  {
    HMODULE user32 = LoadLibrary(L"user32");
    GetTaskmanWindowPtr GetTaskmanWindow =
        (GetTaskmanWindowPtr)GetProcAddress(user32, "GetTaskmanWindow");
    if (!GetTaskmanWindow) {
      throw exception("Failed to get GetTaskmanWindow!");
    }
    HWND htm = GetTaskmanWindow();
    if (!htm) {
      throw exception("Failed to get taskman window");
    }
    HWND htb = FindWindowEx(htm, 0, L"ToolbarWindow32", 0);
    if (!htb) {
      throw exception("Failed to get toolbar window");
    }
    ralloc_t ralloc(htb);
    int count = SendMessage(htb, TB_BUTTONCOUNT, 0, 0);
    cout << count << endl;

    for (int i = 0; i < count; ++i) {
      TBBUTTON tbb;
      TBBUTTON* rtbb = ralloc.create<TBBUTTON>();
      BOOL rv = SendMessage(htb, TB_GETBUTTON, i, (LPARAM)rtbb);
      ralloc.read(rtbb, &tbb);
      ralloc.free(rtbb);
      cout << rv << " " << sizeof(tbb) << " " << tbb.idCommand << " "
           << tbb.iString << endl << flush;

      int chars = SendMessage(htb, TB_GETBUTTONTEXT, tbb.idCommand, (LPARAM)0);
      if (chars <= 0) {
        continue;
      }
      chars++;
      wchar_t* rbuf = ralloc.create<wchar_t>(chars);
      if (SendMessage(htb, TB_GETBUTTONTEXT, tbb.idCommand, (LPARAM)rbuf) > 0) {
        wchar_t* buf = new wchar_t[chars];
        ralloc.read(rbuf, buf);
        wcout << buf << endl << flush;
        delete[] buf;
      }
    }
  }
  catch (const exception& ex)
  {
    cerr << "Error: " << ex.what() << endl;
  }

  // Sleep
  getchar();
  return 0;
}

Answer 1

看来你需要了解一下C++中的类。您看到的是两个 函数。第一个称为 ralloc_t 并且是类的构造函数。第二个称为 ~ralloc_t，是类的析构函数。

  // This is the constructor
  ralloc_t(HWND hwnd) : proc_(0)
  {
    DWORD pid = 0;
    if (!GetWindowThreadProcessId(hwnd, &pid)) {
      throw exception("dang, no dice");
    }
    proc_ = OpenProcess(
        PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION, FALSE, pid);
    if (!proc_) {
      throw exception("no open for me!");
    }
  }

  // This is the destructor
  ~ralloc_t()
  {
    buffers_t::reverse_iterator i = buffers_.rbegin(), e = buffers_.rend();
    for (; i != e; ++i) {
      free(i->first);
    }
  }

请注意，构造函数与类同名(参见 class ralloc_t 行)，析构函数同名但以波浪号为前缀(~ ).

这些函数，就其本质而言，不返回任何东西。构造函数的目的是在构造时初始化ralloc_t类型的对象，而析构函数的目的是在销毁时进行清理。

例如，您可能有一段代码如下所示:

{
  ralloc_t my_ralloc(some_hwnd);
  // ...
}

my_ralloc 的声明会调用构造函数(传递 some_hwnd 作为构造函数的参数)。析构函数将在 block 的末尾调用，也就是变量超出范围并被销毁时。