在C ++中“横向”类型转换指针时会发生什么

Question

I'm not that experienced with C++, but trying to learn.

The following example consists of a hierarchy of classes which are "related":

• Child is a child of both Parent1 and Parent2
• Parent2 is a child of VirtualGrandParent .
• Parent2 contains a member Sister* m_sister which is a pointer to another user-defined object type. This is initialized and allocated memory with keyword new in Parent2's constructor. At some point in the execution this pointer is set to 0.

MainClass.cpp:

#include "WorkerClass.h"
using namespace std;

int main() 
{ 
  WorkerClass worker;

  worker.initialize();
  worker.setProperty1();
  worker.setProperty2();
// At this point m_sister (in Parent2) is set to 0x0, which makes the next method call fail (Segmentation fault). What happens?

  worker.setAuntValue();

  return 0;
}

WorkerClass.h:

#include <map>
#include "Child.h"

class WorkerClass
{
public:
    void initialize()
    {
        Child* child1 = new Child();
        m_myMap[0] = child1;
    }

    void setProperty1()
    {
        VirtualGrandParent* ptr = m_myMap[0];
        ((Parent1*) ptr)->setProperty1(6.0);
    }

    void setProperty2()
    {
        VirtualGrandParent* ptr = m_myMap[0];
        ((Parent1*) ptr)->setProperty2(7.0);
    }

    void setAuntValue()
    {
        VirtualGrandParent* ptr = m_myMap[0];
        ((Child*) ptr)->setSisterValue(170.0);
    }

private:
    map<int, VirtualGrandParent*> m_myMap;
};

Child.h

#include "Parent1.h"
#include "Parent2.h"

class Child : public Parent1, public Parent2
{
public:
    Child(): Parent1(), Parent2() {}
    ~Child(){};
};

Parent1.h:

class Parent1
{
public:

    Parent1(): m_value1(0.0), m_value2(0.0) {}
    virtual ~Parent1() {};

    void setProperty1(double val) {m_value1=val;}
    void setProperty2(double val) {m_value2=val;}

private:
    double m_value1;
    double m_value2;
};

Parent2.h:

#include "Sister.h"
#include "VirtualGrandParent.h"

class Parent2 : public VirtualGrandParent
{
public:
    Parent2(): VirtualGrandParent() {m_sister = new Sister();}
    ~Parent2(){};

    void setSisterValue(double val){m_sister->setValue(val);}

protected:
    Sister* m_sister;
};

Sister.h:

class Sister {
public:
    Sister(): m_sisterVal(0.0) {};

    void setValue(double val)
    {
        m_sisterVal=val;
    }
private:
    double m_sisterVal;
};

VirtualGrandParent.h:

class VirtualGrandParent
{
public:
    VirtualGrandParent() {}
    virtual ~VirtualGrandParent(){};
};

Question 1 : So my main question is what happens during the "sideways" casting from VirtualGrandParent to Parent1? Why is m_sister 0? Is memory overwritten? Why does it take two method calls before m_sister is 0?

Question 2 : What happens if taking the address to the pointer ptr in WorkerClass.h, and then cast it to a Parent1* pointer (example below)? Executing the code with this change results in m_sister not being set to 0. I assume this is just a coincidence? (I guess a pointer-to-pointer really should be of type Parent1** ?)

void setProperty1()
{
    VirtualGrandParent* ptr = m_myMap[0];
    ((Parent1*) &ptr)->setProperty1(6.0);
}

Answer 1

So if we view the parentage as a tree:

VirtualGrandParent
       \
      Parent2        Parent1
            \       /
              Child

Then we can see that Parent1 and VirtualGrandParent are on different branches. So when you cast VirtualGrandParent* ptr to Parent1 you aren't properly casting up or down the hierarchy. Instead that's casting across it which ends up casting between unrelated classes - and that's why it yields invalid results.

For casting along an inheritance hierarchy, try to always use at least static_cast (or dynamic_cast if desired). With a static_cast the compiler will validate that the cast is at least possible and otherwise give an error. In your case it should show an error.

The proper cast would be static_cast<Parent1*>(static_cast<Child*>(ptr))

As for your second question about &ptr ... casting a pointer-to-a-pointer as a pointer-to-a-class is simply nonsense. If it appears work at all, that's the unfortunate luck of undefined behavior. (And it's probably not actually working correctly, but instead interpreting some arbitrary memory as if it was your class, which then happens to have a non-zero value where somePtr would be but isn't valid in any way.)