C++将派生类赋值给基类（向上转型）
Posted C语言学习联盟
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++将派生类赋值给基类（向上转型）相关的知识，希望对你有一定的参考价值。
数据类型转换的前提是，编译器知道如何对数据进行取舍。例如：
-
int a
=
10.9
;
-
printf
(
"%d
\n
"
, a
);
-
float b
=
10
;
-
printf
(
"%f
\n
"
, b
);
类其实也是一种数据类型，也可以发生数据类型转换，不过这种转换只有在基类和派生类之间才有意义，并且只能将派生类赋值给基类，包括将派生类对象赋值给基类对象、将派生类指针赋值给基类指针、将派生类引用赋值给基类引用，这在 C++ 中称为向上转型（ Upcasting ）。相应地，将基类赋值给派生类称为向下转型（ Downcasting ）。
向上转型非常安全，可以由编译器自动完成；向下转型有风险，需要程序员手动干预。本节只介绍向上转型，向下转型将在后续章节介绍。
将派生类对象赋值给基类对象
-
#include
<iostream>
-
u
sin
g
namespace std
;
-
//基类
-
class A
{
-
public
:
-
A
(
int a
);
-
public
:
-
void
display
();
-
public
:
-
int m_a
;
-
}
;
-
A
::
A
(
int a
):
m_a
(a
)
{
}
-
void A
::
display
()
{
-
cout
<<
"Class A: m_a="
<<m_a
<<endl
;
-
}
-
//派生类
-
class B
:
public A
{
-
public
:
-
B
(
int a
,
int b
);
-
public
:
-
void
display
();
-
public
:
-
int m_b
;
-
}
;
-
B
::
B
(
int a
,
int b
):
A
(a
),
m_b
(b
)
{
}
-
void B
::
display
()
{
-
cout
<<
"Class B: m_a="
<<m_a
<<
", m_b="
<<m_b
<<endl
;
-
}
-
int
main
()
{
-
A
a
(
10
);
-
B
b
(
66
,
99
);
-
//赋值前
-
a
.
display
();
-
b
.
display
();
-
cout
<<
"--------------"
<<endl
;
-
//赋值后
-
a
= b
;
-
a
.
display
();
-
b
.
display
();
-
return
0
;
-
}
Class A: m_a=10
Class B: m_a=66, m_b=99
----------------------------
Class A: m_a=66
Class B: m_a=66, m_b=99
本例中 A 是基类， B 是派生类，a、b 分别是它们的对象，由于派生类 B 包含了从基类 A 继承来的成员，因此可以将派生类对象 b 赋值给基类对象 a。通过运行结果也可以发现，赋值后 a 所包含的成员变量的值已经发生了变化。
赋值的本质是将现有的数据写入已分配好的内存中，对象的内存只包含了成员变量，所以对象之间的赋值是成员变量的赋值，成员函数不存在赋值问题。 运行结果也有力地证明了这一点，虽然有
a=b;
这样的赋值过程，但是 a.display() 始终调用的都是 A 类的 display() 函数。换句话说，对象之间的赋值不会影响成员函数，也不会影响 this 指针。
这种转换关系是不可逆的，只能用派生类对象给基类对象赋值，而不能用基类对象给派生类对象赋值。 理由很简单，基类不包含派生类的成员变量，无法对派生类的成员变量赋值。同理，同一基类的不同派生类对象之间也不能赋值。
要理解这个问题，还得从赋值的本质入手。赋值实际上是向内存填充数据，当数据较多时很好处理，舍弃即可；本例中将 b 赋值给 a 时（执行
a=b;
语句），成员 m_b 是多余的，会被直接丢掉，所以不会发生赋值错误。但当数据较少时，问题就很棘手，编译器不知道如何填充剩下的内存；如果本例中有
b= a;
这样的语句，编译器就不知道该如何给变量 m_b 赋值，所以会发生错误。
将派生类指针赋值给基类指针
-
#include
<iostream>
-
using
namespace std
;
-
//基类A
-
class A
{
-
public
:
-
A
(
int a
);
-
public
:
-
void
display
();
-
protected
:
-
int m_a
;
-
}
;
-
A
::
A
(
int a
):
m_a
(a
)
{
}
-
void A
::
display
()
{
-
cout
<<
"Class A: m_a="
<<m_a
<<endl
;
-
}
-
//中间派生类B
-
class B
:
public A
{
-
public
:
-
B
(
int a
,
int b
);
-
public
:
-
void
display
();
-
protected
:
-
int m_b
;
-
}
;
-
B
::
B
(
int a
,
int b
):
A
(a
),
m_b
(b
)
{
}
-
void B
::
display
()
{
-
cout
<<
"Class B: m_a="
<<m_a
<<
", m_b="
<<m_b
<<endl
;
-
}
-
//基类C
-
class C
{
-
public
:
-
C
(
int c
);
-
public
:
-
void
display
();
-
protected
:
-
int m_c
;
-
}
;
-
C
::
C
(
int c
):
m_c
(c
)
{
}
-
void C
::
display
()
{
-
cout
<<
"Class C: m_c="
<<m_c
<<endl
;
-
}
-
//最终派生类D
-
class D
:
public B
,
public C
{
-
public
:
-
D
(
int a
,
int b
,
int c
,
int d
);
-
public
:
-
void
display
();
-
private
:
-
int m_d
;
-
}
;
-
D
::
D
(
int a
,
int b
,
int c
,
int d
):
B
(a
, b
),
C
(c
),
m_d
(d
)
{
}
-
void D
::
display
()
{
-
cout
<<
"Class D: m_a="
<<m_a
<<
", m_b="
<<m_b
<<
", m_c="
<<m_c
<<
", m_d="
<<m_d
<<endl
;
-
}
-
int
main
()
{
-
A
*pa
=
new
A
(
1
);
-
B
*pb
=
new
B
(
2
,
20
);
-
C
*pc
=
new
C
(
3
);
-
D
*pd
=
new
D
(
4
,
40
,
400
,
4000
);
-
pa
= pd
;
-
pa
->
display
();
-
pb
= pd
;
-
pb
->
display
();
-
pc
= pd
;
-
pc
->
display
();
-
cout
<<
"-----------------------"
<<endl
;
-
cout
<<
"pa="
<<pa
<<endl
;
-
cout
<<
"pb="
<<pb
<<endl
;
-
cout
<<
"pc="
<<pc
<<endl
;
-
cout
<<
"pd="
<<pd
<<endl
;
-
return
0
;
-
}
Class A: m_a=4
Class B: m_a=4, m_b=40
Class C: m_c=400
-----------------------
pa=0x9b17f8
pb=0x9b17f8
pc=0x9b1800
pd=0x9b17f8
本例中定义了多个对象指针，并尝试将派生类指针赋值给基类指针。与对象变量之间的赋值不同的是，对象指针之间的赋值并没有拷贝对象的成员，也没有修改对象本身的数据，仅仅是改变了指针的指向。
1) 通过基类指针访问派生类的成员
pa 本来是基类 A 的指针，现在指向了派生类 D 的对象，这使得隐式指针 this 发生了变化，也指向了 D 类的对象，所以最终在 display() 内部使用的是 D 类对象的成员变量，相信这一点不难理解。
编译器虽然通过指针的指向来访问成员变量，但是却不通过指针的指向来访问成员函数：编译器通过指针的类型来访问成员函数。对于 pa，它的类型是 A，不管它指向哪个对象，使用的都是 A 类的成员函数。
概括起来说就是：编译器通过指针来访问成员变量，指针指向哪个对象就使用哪个对象的数据；编译器通过指针的类型来访问成员函数，指针属于哪个类的类型就使用哪个类的函数。
2) 赋值后值不一致的情况
pc = pd;
语句后，pc 和 pd 的值并不相等。
将派生类引用赋值给基类引用
修改上例中 main() 函数内部的代码，用引用取代指针：
-
int
main
()
{
-
D
d
(
4
,
40
,
400
,
4000
);
-
A
&ra
= d
;
-
B
&rb
= d
;
-
C
&rc
= d
;
-
ra
.
display
();
-
rb
.
display
();
-
rc
.
display
();
-
return
0
;
-
}
Class A: m_a=4
Class B: m_a=4, m_b=40
Class C: m_c=400
ra、rb、rc 是基类的引用，它们都引用了派生类对象 d，并调用了 display() 函数，从运行结果可以发现，虽然使用了派生类对象的成员变量，但是却没有使用派生类的成员函数，这和指针的表现是一样的。
最后需要注意的是，向上转型后通过基类的对象、指针、引用只能访问从基类继承过去的成员（包括成员变量和成员函数），不能访问派生类新增的成员。
以上是关于C++将派生类赋值给基类（向上转型）的主要内容，如果未能解决你的问题，请参考以下文章