visual studio C++ 测试：

#include <iostream>
#include <algorithm>


class A
{
public:
    virtual ~A() {}
    A()
    {
        std::fill(arrA, arrA + 3, 1);
    }
    int arrA[3];
};


class B
{
public:
    B()
    {
        std::fill(arrB, arrB + 5, 5);
    }
    virtual ~B() {}
    int arrB[5]{ 5 };
};


class C :public A, public B
{
public:
    C()
    {
        std::fill(arrC, arrC + 7, 7);
    }
    int arrC[7];
};



int main()
{
    C *pC = new C;
    std::cout << "原对象，派生类地址：" << pC << '\n' << std::endl;
    A *pA = pC;
    std::cout << "基类 A 接收派生类地址：" << pA << '\n' << std::endl;
    B *pB = static_cast<C *>(pA);    // 没问题
    std::cout << "基类 B 接收派生类地址：" << pB << '\n' << std::endl;
    
    //B *pB1 = static_cast<B *>(pA);   // 编译器报错
   
    B *pB2 = pC;
    std::cout << "基类 B 接收派生类地址：" << pB2 << '\n' << '\n';

    //if (pA == pB2) { }    // 编译器报错，不能直接比较。

    auto pAVoid = static_cast<void *>(pA);
    auto pBVoid = static_cast<void *>(pB2);
    if (pAVoid == pBVoid) {  // 不相等
        std::cout << pAVoid << '\n';
    }
    else {
        std::cout << "static_cast 转换不相等：\n" << "a:" << pAVoid
            << '\n' << "b:" << pBVoid << '\n' << std::endl;
    }

    pAVoid = dynamic_cast<void *>(pA);
    pBVoid = dynamic_cast<void *>(pB2);
    if (pAVoid == pBVoid) {  // 相等
        std::cout << "dynamic_cast 转化相等，地址：" << pAVoid << '\n' << std::endl;
    }

    getchar();
    return 0;
}

输出：

原对象，派生类地址：0000019BF212D150

基类 A 接收派生类地址：0000019BF212D150

基类 B 接收派生类地址：0000019BF212D168

基类 B 接收派生类地址：0000019BF212D168

static_cast 转换不相等：
a:0000019BF212D150
b:0000019BF212D168

dynamic_cast 转化相等，地址：0000019BF212D150

结果：

1. A, B 兄弟类型之间不能 static_cast 转换，只能 dynamic_cast 转换；
2. 在明确知道基类指针指向的时派生类时，可以 static_cast 转换成派生类给兄弟类指针接收。
3. 第一基类 A 的地址和原始对象地址相等；
4. 兄弟类指针虽然都接受的同一派生类对象，但地址是有偏置的，直接 static_cas<void *> 是不相等的，但 dynamic_cast<void *> 转换后都升到派生类地址，从而比较是相等的。 // 是不是直接 dynamic_cast<C *> 更为直观