cpp中非静态成员函数实际上的参数个数比表面上看到的多一个，多出来的参数就是 this 指针。对吗？

是的，C++ 中非静态成员函数实际上的参数个数比表面上看到的多一个，多出来的参数就是 `this` 指针。`this` 指针指向当前对象的地址，在非静态成员函数内部可以用来访问当前对象的成员变量和成员函数。

在 C++ 中，可以通过以下两种方式来访问成员函数：

1. 通过对象来调用成员函数，例如 `obj.func()`。
2. 通过指向对象的指针或引用来调用成员函数，例如 `ptr->func()` 或 `ref.func()`。

对于第一种方式，编译器会自动将对象的地址作为隐含参数传递给成员函数，因此在非静态成员函数内部可以直接访问对象的成员变量和成员函数，无需显式传递对象的地址。

而对于第二种方式，需要显式传递对象的地址，可以使用 `this` 指针来传递。例如，在成员函数内部可以使用 `this->member` 来访问对象的成员变量，或者使用 `this->func()` 来调用对象的成员函数。

因此，可以说非静态成员函数实际上的参数个数比表面上看到的多一个，多出来的参数就是 `this` 指针。

相关问题

重载为成员函数时，参数个数为运算符数目减一。 正确吗

不完全正确。重载为成员函数时，参数个数应该为运算符数目减一，但是必须包括一个隐式的this指针作为第一个参数。例如，如果要重载二元运算符+作为成员函数，参数应该是一个const引用类型的对象，然后函数声明应该是这样的:

class MyClass {
public:
    MyClass operator+(const MyClass& obj) const;
};

注意到函数的第一个参数是一个const引用类型的MyClass对象，并且函数声明中没有指定第一个参数的名称，因为它是隐式的。

C++ 类Thunk技术示例代码使用VirtualAlloc静态函数使用类里面成员，使用this指针，函数指针不可以有参数

如果您想使用类Thunk技术和VirtualAlloc来创建一个静态函数，该函数可以使用类内的成员变量，并且不带参数，可以使用函数指针的类成员函数形式，而不是静态函数。以下是一个示例代码：

#include <iostream>
#include <Windows.h>
#include <functional>

class CallbackClass {
public:
    int memberVariable;

    void MemberCallback() {
        // 使用类的成员
        std::cout << "Member variable: " << memberVariable << std::endl;
    }

    static void* GetCallbackInstance() {
        // 通过VirtualAlloc分配的内存块中存储类的实例指针
        LPVOID executableMemory = VirtualAlloc(NULL, sizeof(CallbackClass), MEM_COMMIT, PAGE_READWRITE);
        return executableMemory;
    }
};

int main() {
    // 创建一个类对象并设置成员变量
    CallbackClass instance;
    instance.memberVariable = 42;

    // 将类对象的指针保存在可执行的内存块中
    void* callbackInstance = CallbackClass::GetCallbackInstance();
    memcpy(callbackInstance, &instance, sizeof(CallbackClass));

    // 创建一个函数指针指向类的成员函数
    typedef void (CallbackClass::*MemberCallbackFunc)();
    MemberCallbackFunc memberThunk = &CallbackClass::MemberCallback;

    // 转换并调用类的成员函数
    CallbackClass* callbackObject = reinterpret_cast<CallbackClass*>(callbackInstance);
    std::function<void()> memberCallback = std::bind(memberThunk, callbackObject);
    memberCallback();

    // 释放内存
    VirtualFree(callbackInstance, 0, MEM_RELEASE);

    return 0;
}

在这个示例中，我们定义了一个包含成员函数 `MemberCallback` 和成员变量 `memberVariable` 的 `CallbackClass` 类。

然后，我们使用 `GetCallbackInstance` 函数通过 `VirtualAlloc` 分配一块可执行的内存，并将类的实例指针存储在其中。

接下来，我们创建一个函数指针 `memberThunk`，指向类的成员函数 `MemberCallback`。

然后，我们通过将类对象的指针转换为 `CallbackClass*` 类型，并使用 `std::bind` 创建一个 `std::function` 对象 `memberCallback`，将成员函数指针和类对象绑定。

最后，我们通过调用 `memberCallback()` 来执行类的成员函数，从而访问类的成员变量。

请注意，这个示例代码使用了类Thunk技术和VirtualAlloc函数，使得函数指针可以调用类的成员函数，并访问类内的成员变量。在实际应用中，您可能需要考虑更多的安全性和错误处理机制。