C/C++指针都能转为void*吗？

在C/C++开发中，void*常被当作一种“通用指针”使用。很多开发者形成了一种直觉：既然指针本质上是地址，那么任何地址都应该可以放进void*。但这一直觉并不完全正确。C++标准对指针类型做了严格分类，某些指针不仅不能隐式转换为void*，甚至使用强制类型转换也无法通过编译。

本文将从C++对象模型、成员函数调用机制、多重继承内存布局和虚函数实现等角度，系统解释“为什么并非任何指针都能转换为void*”，并给出可直接运行的示例代码。

一、指针并不只有“地址”一种含义

在大多数现代64位操作系统上，一个普通对象指针，例如int*、char*、void*，通常占用8字节。这个8字节的内容一般是一个虚拟地址，指向进程地址空间中的某个位置。

因此，很多人会认为所有指针都应该是8字节，都应该能互相转换。但实际上，下面这个程序会给出不同的结果：

#include <iostream>
class Base {
public:
    void f() {}
};
int main() {
    std::cout << "Size of void*: "
              << sizeof(void*) << " bytes" << std::endl;
    std::cout << "Size of Member Function Pointer: "
              << sizeof(&Base::f) << " bytes" << std::endl;
    return 0;
}

在常见编译器上，输出可能是：

Size of void*: 8 bytes
Size of Member Function Pointer: 16 bytes

可以看到，成员函数指针并不是8字节，而是16字节。显然，它不只是一个简单地址。如果强行将其塞进一个void*，就必然发生数据截断，从而破坏指针语义。

二、C++中的两类指针

C++标准将指针划分为两大类，二者互不兼容：

1. 对象指针
   包括void*、int*、double*、结构体指针、类对象指针等。

2. 成员指针
   包括成员变量指针和成员函数指针。

例如：

struct Test {
    int value;
    void funct();
};
void* p1 = reinterpret_cast<void*>(&Test::funct); // 错误

这段代码在C++编译器下会产生类似如下错误：

invalid cast from type 'void (Test::*)()' to type 'void*'

这说明成员函数指针与void*之间存在类型系统层面的隔离。这种隔离并不是语言设计者的随意限制，而是由C++对象模型的实际需求决定的。

三、为什么成员函数不能仅用一个地址表示？

普通全局函数或静态成员函数不属于任何对象。它们没有this指针，也不会因为继承关系产生对象偏移。因此，它们可以像普通函数指针一样，使用一个入口地址表示。

但非静态成员函数不同。编译器在调用非静态成员函数时，必须隐式传入this指针。this指针指向调用该成员函数的那个对象。

问题在于，当存在继承时，成员函数真正所属的子对象可能并不位于完整对象的起始位置。

例如：

class Base1 {
public:
    int x;
    void f() {}
};
class Base2 {
public:
    int y;
    void g() {}
};
class Derived : public Base1, public Base2 {
public:
    int z;
};

在多重继承下，Derived对象的布局中，Base1子对象和Base2子对象不可能同时位于对象起始地址。因此，调用不同基类的成员函数时，this指针的值可能需要调整。

例如当调用Base2::g()，而调用者拿到的是一个Derived*时，编译器在传递this之前，需要将指针偏移到Base2子对象的位置。

所以，成员函数指针不仅要能定位函数代码，还要记录以下信息：

• 函数入口地址；
• 调用时需要加到this指针上的偏移量；
• 如果目标是虚函数，还可能需要虚函数表索引。

这些信息不能压缩进一个void*。

四、调用约定与this指针的传递机制

在常见C++ ABI中，非静态成员函数的调用通常采用一种特殊的内部调用约定。成员函数在编译后，类似于普通函数增加了一个隐藏参数：

void Base::f(Base* this);

这个隐藏参数可以放在寄存器中，也可以放在栈上，取决于目标平台和调用约定。但无论采用何种方式，调用方都必须正确计算this的值。

考虑如下调用：

Derived d;
Base2* p = &d;   // 编译器自动调整了偏移
p->g();          // 调用 Base2::g()

在p = &d这一步，编译器已经知道Base2在Derived中的偏移量，因此它能把Derived*转换为正确的Base2*。

但成员函数指针的保存与调用可能发生在完全不同的位置。例如，把&Derived::g保存起来，之后再通过某个Derived*调用。此时指针中必须携带足够的偏移信息，才能让调用方重新构造出正确的this。

因此，一个典型的成员函数指针在Itanium C++ ABI中，可以理解为类似以下结构：

struct {
    void* ptr;      // 函数地址，或者虚函数表相关偏移
    ptrdiff_t adj;  // this指针调整值
};

在某些实现中，还会针对普通成员函数、虚函数、多重继承等情况使用不同编码方式。

五、虚函数让成员函数指针更加复杂

虚函数的调用并不是直接跳转到一个固定地址，而是通过虚函数表间接查找。

例如：

class Base {
public:
    virtual void f();
    virtual void g();
};
class Derived : public Base {
public:
    void f() override;
};

调用虚函数时，实际执行的函数取决于对象的动态类型。编译器通常通过以下步骤完成调用：

1. 从对象起始位置读取虚函数表指针；
2. 根据函数在虚函数表中的索引查找函数地址；
3. 调用该地址。

因此，指向虚函数的成员函数指针可能并不保存具体函数地址，而是保存一个虚函数表索引。调用时再根据对象实际的虚函数表查找最终目标。

这种机制进一步说明，成员函数指针不能简单等同于void*。它可能是一个复合信息结构，包含编码后的函数地址或索引，以及this调整量。

六、静态成员函数为什么可以被void*接收？

静态成员函数与普通全局函数在调用方式上几乎一致。它们没有隐式this参数，不依赖对象状态，也不涉及基类子对象偏移。

因此，静态成员函数指针通常就是一个普通函数指针，其大小与void*相同，可以通过reinterpret_cast转换。

例如：

class Test {
public:
    static void helper() {}
};
void* p = reinterpret_cast<void*>(&Test::helper);

这里可以编译通过，因为静态成员函数不涉及对象模型中的复杂信息。

七、将成员函数指针转换为void*会带来什么风险？

假设某种编译器允许这种转换，并且在数值上保留了一部分信息，风险仍然非常明显：

1. 数据截断
   成员函数指针通常大于void*。转换后可能丢失this偏移信息，导致后续调用错误。

2. 破坏类型安全
   void*丢失了成员函数指针的类型信息。即使数据没有截断，调用者也无法知道如何正确还原并调用该指针。

3. 跨编译器、跨平台不一致
   成员函数指针的内部表示并不是C++标准规定的，而是由实现定义的。不同编译器甚至同一编译器不同版本都可能不同。依赖这种转换会导致代码不可移植。

4. 虚函数调用错误
   如果成员函数指针表示虚函数索引，却当成普通地址存储到void*中，后续转换为普通函数指针并调用，会直接导致未定义行为。

八、结论

C++中并非任何指针都能转换为void*。对象指针和成员指针属于两类完全不同的指针体系，它们的大小、内部结构和调用语义都存在本质差异。

普通对象指针通常是一个简单地址，而成员函数指针则是一个复合信息结构，需要表示函数入口、this指针调整量以及虚函数表信息。正是由于C++对象模型中的调用约定、继承布局和虚函数机制，才使得void*无法承载成员函数指针的全部信息。

理解这一点，有助于开发者避免在使用函数指针、回调机制、反射系统或跨语言调用时引入危险的类型转换。指针并不是简单的整数地址，它承载着编译器和运行时对类型、对象布局以及调用语义的完整约定。