C++ 为什么我需要强制转换来访问基类的实际值？

我有一个从

a

派生出来的类

B

，其中有一个名为

type

的成员，我想从类

B

的方法中访问它，但是我得到的不是实际值，而是

0

，但是如果我在

B

方法中将

这个
转换为
a
，它会工作得很好，就像这样：
（（a*）this）->键入
，这样就可以给我实际值，而不是
0
。有人能解释一下吗？我编写了一个实际类的简短版本来给出一个代码示例

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

enum TYPE
{
    T_INTEGER = 2,
  T_FLOAT = 4
};

struct A
{
  enum TYPE type;
  A(enum TYPE);
  A();
  int print();
};

struct B : A
{
  enum TYPE type;
  B(enum TYPE);
};

struct Number : B
{
  union
  {
        int intvalue;
        float floatvalue;
  };
  Number(int);
    int print();
};

A::A() { }

A::A(enum TYPE Type)
    : type(Type)
{
}

B::B(enum TYPE kind) :
  A(kind)
{
}


Number::Number(int v)
  : B(T_INTEGER),
    intvalue(v)
{
}

int Number::print()
{
    printf("type = %d\n", type); // output: type = 0 (wrong)
    printf("type = %d\n", ((A*)this)->type); // output type = 2 (correct) but why do I need cast?

    switch(((A*)this)->type)
    {
  case T_INTEGER:
    return printf("%d", intvalue);
  case T_FLOAT:
    return printf("%g", floatvalue);
    default:
        assert(0);
    }
}

int main()
{
    Number *n = new Number(2);
    n->print();
    delete n;
}

#包括
#包括
#包括
枚举类型
{
T_整数=2，
T_FLOAT=4
};
结构A
{
枚举类型；
A（枚举类型）；
A（）；
int print（）；
};
结构B:A
{
枚举类型；
B（枚举类型）；
};
结构编号：B
{
联盟
{
int值；
浮点数；
};
数字（整数）；
int print（）；
};
A:：A（）{}
A:：A（枚举类型）
：type（type）
{
}
B:：B（枚举类型种类）：
A（类）
{
}
数字：：数字（int v）
：B（T_整数），
intvalue（v）
{
}
int Number:：print（）
{
printf（“type=%d\n”，type）；//输出：type=0（错误）
printf（“type=%d\n”，（（A*）this）->type）；//输出类型=2（正确），但为什么需要强制转换？
开关（（（A*）此）->类型）
{
案例T_整数：
返回printf（“%d”，intvalue）；
案例T_浮动：
返回printf（“%g”，floatvalue）；
违约：
断言（0）；
}
}
int main（）
{
编号*n=新编号（2）；
n->print（）；
删除n；
}
您已经声明了一个成员变量

enum TYPE type;

在类
B
和
A
中，但您的
B
构造函数从不使用该名称初始化自己的变量-它只是将其传递给初始化
A:：type
的
A
构造函数

B::B(enum TYPE kind) :
   A(kind)
{
}

因此，
B
成员从未初始化。不清楚为什么您在派生类
B
中再次添加了一个相同名称和类型的变量，但我猜想您可能并不打算这样做，而是希望在基类
a
中只添加一个这种类型的变量

当派生类和基类中的变量名和类型都相同时，派生类成员会隐藏基类成员-这就是从
Number:：print（）
方法访问
type
时引用
B
成员而不是
a
成员的原因。显然，然后将
此
转换为
A*
将访问
A:：type
成员。
您已经声明了一个成员变量

enum TYPE type;

在类
B
和
A
中，但您的
B
构造函数从不使用该名称初始化自己的变量-它只是将其传递给初始化
A:：type
的
A
构造函数

B::B(enum TYPE kind) :
   A(kind)
{
}

因此，
B
成员从未初始化。不清楚为什么您在派生类
B
中再次添加了一个相同名称和类型的变量，但我猜想您可能并不打算这样做，而是希望在基类
a
中只添加一个这种类型的变量

当派生类和基类中的变量名和类型都相同时，派生类成员会隐藏基类成员-这就是从
Number:：print（）
方法访问
type
时引用
B
成员而不是
a
成员的原因。显然，然后将
此
转换为
A*
将访问
A:：type
成员。
您已经声明了一个成员变量

enum TYPE type;

在类
B
和
A
中，但您的
B
构造函数从不使用该名称初始化自己的变量-它只是将其传递给初始化
A:：type
的
A
构造函数

B::B(enum TYPE kind) :
   A(kind)
{
}

因此，
B
成员从未初始化。不清楚为什么您在派生类
B
中再次添加了一个相同名称和类型的变量，但我猜想您可能并不打算这样做，而是希望在基类
a
中只添加一个这种类型的变量

当派生类和基类中的变量名和类型都相同时，派生类成员会隐藏基类成员-这就是从
Number:：print（）
方法访问
type
时引用
B
成员而不是
a
成员的原因。显然，然后将
此
转换为
A*
将访问
A:：type
成员。
您已经声明了一个成员变量

enum TYPE type;

在类
B
和
A
中，但您的
B
构造函数从不使用该名称初始化自己的变量-它只是将其传递给初始化
A:：type
的
A
构造函数

B::B(enum TYPE kind) :
   A(kind)
{
}

因此，
B
成员从未初始化。不清楚为什么您在派生类
B
中再次添加了一个相同名称和类型的变量，但我猜想您可能并不打算这样做，而是希望在基类
a
中只添加一个这种类型的变量

当派生类和基类中的变量名和类型都相同时，派生类成员会隐藏基类成员-这就是从
Number:：print（）
方法访问
type
时引用
B
成员而不是
a
成员的原因。显然，然后将
this
强制转换为
A*
将访问
A:：type
成员。
您在
A
和
B
中声明了成员变量
type
。但是
B
从
A
继承成员变量
type
。这意味着
B
类型的每个对象都包含两个
type
变量：
A:：type
和
B:：type