为什么父类指针可以指向子类反之则不行（内存长度不同）

例如: 
class a 
{public: 
int aa};

class b:public a 
{public: 
int bb; 
} 
从内存的来看 
如a 
－－－－－－－－－| 
|占一个int数据大小--| 
|----（aa数据）------| 
|－－－－－－－－－ 
而b则是 
－－－－－－－－－|－－－－－－－－－ 
|占一个int数据大小--|占一个Int数据大小--| 
|从a中继承而来------|---（bb数据----------| 
|－－－－－－－－－－－－－－－－－－ 
当定义一个基类类型的指针时 
a *p;这时，这个指针指向的是a类型的数据 
当p指针指向派生类的时候，因为p是a类型的指针，所以*p只解释为a类型数据的长度，即
————————－|－－－－－－－－－ 
|占一个int数据大小--|占一个Int数据大小--| 
|从a中继承而来------|-----（bb数据)-------| 
|－－－－－－－－－－－－－－－－－－ 
|------------|------------| 
|-p只指向这个区域_--|

因此，当基类的指针（P）指向派生类的时候，只能操作派生类中从基类中继承过来的数据。 
指向派生类的指针，因为内存空间比基类长，会导致严重了后果，所以不允许派生类的指针指向基类。而基类的指针可以指向派生类。

C++的多态性能解决基类指针不能操作派生类的数据成员的问题。

用C++比较好说明白:       
  1:指针的可访问性是由指针的定义决定的,比如说用BaseClass定义的指针,可访问的范围就是BaseClass的内存区域       
  2:允许用一个指向基类的指针指向派生类,由于被指向的对象的内存空间大于指针的可访问空间,所以这种向上映射是安全的       
  3:对象在调用虚函数的时候,是调用父类的函数还是调用派生类的函数,是和对象的类型有关的,比如说一个派生类B,其父类是A,则B的对象调用父类中被声明为VIRTUAL的函数时,被B   所OVERRIDE的函数调用的是B里的函数,而B没有OVERRIDE的函数调用的是基类里的函数

http://blog.csdn.net/yiruirui0507/article/details/6007767

时间： 2024-10-18 15:21:03

为什么父类指针可以指向子类反之则不行（内存长度不同）的相关文章

父类指针可以指向子类指针，反之则不能

例如:class a{public:int aa};class b:public a{public: int bb;}从内存的来看如a---------||占一个int数据大小--||----(aa数据)------||---------而b则是---------|---------|占一个int数据大小--|占一个Int数据大小--||从a中继承而来------|---(bb数据----------||------------------当定义一个基类类型的指针时a *p;这时,这个指针指向的

父类的引用指向子类的对象或者接口指向实现类均是可以的

父类的引用指向子类的对象或者接口指向实现类均是可以的. 例如(下图为父类的引用指向子类的对象) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public class Father {         public void pri() {             System.out.println("father");         } } public class Sun   extends  Father{       public void 

父类的引用指向子类的对象

1.Father.java package com.ljb.extend; public class Father {  public int x = 10;  public int fGet() {   return x;  } } 2.Son.java package com.ljb.extend; public class Son extends Father {  // 不能出现与父类同名属性  public int a = 100;  public int fGet() {   Sys

父类的指针无法指向子类对象

父类的指针指向子类的对象,这一特性在c++中叫做多态. 当然,多态还可以有更深的解释. 可是,为什么有时候父类的指针指向不了子类的对象? 有如下两个文件的代码: //B.h class B : public A{}; //main.cpp    Class A; Class B;   void fun(B* b) {     A* a = b;  //这边有错       } 原因是这样子的,有时候我们为了提高编译速度, 会做一些前置声明,比如Class A 告诉编译器A存在. 而后我们可以 A

为什么父类引用可以指向子类对象 子类引用不能指向父类对象 泛型

假设有父类Fu ,其子类为Zi ,从对象的内存角度,假设Fu类里面的变量占内存2M, Zi 类里的变量占内存1M: Fu f = new Fu ();//系统将分配2M内存 Zi z = new Zi ();//系统将分配3M内存(2+1) 因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.所以z可以调用父类的方法. Zi z1= z; //z1指向那3M的内存. Fu f1 = (Fu)z;//这时f1会指向那3M内存中

腾讯2011一道父类指针和子类指针转化的题目

class ClassA { public: virtual ~ClassA(){} virtual void FunctionA(){} }; class ClassB { public: virtual void FunctionB(){} }; class ClassC :public ClassA , public ClassB { }; 关于pA,pB,pC的取值,下面的描述中正确的是: A.pA,pB,pC的取值相同. B.pC=pA+pB C.pA,pB不相同 D.pC不等于pA也

OC3-父类指针指向子类对象

// // Cat.h // OC3-父类指针指向子类对象 // // Created by qianfeng on 15/6/17. // Copyright (c) 2015年 qianfeng. All rights reserved. // #import "Animal.h" @interface Cat : Animal { float _height; } @property (assign,nonatomic)float height; @end // // Cat.m

父类引用指向子类的对象；

public class Tuzi {         //父类  public String name; public void show(){   System.out.println(name+"是个笨蛋");  }  public Tuzi(){     }  public Tuzi(String name){   this.name=name;   } public void setname(String name){   this.name=name;  }  public

用父类引用指向子类好处

子类为了省事就继承父类中的一些东西,,子类如果想把父类的方法改一下就出现了重写,子类想要自立门户也调用自己的东西就出现了多态里面的向下转型,(注意这里使用了也字) 那不将父类的引用指向子类照样可以调用子类里面的东西,为什么那么费事还要向下转型? 因为想要用父类的东西啊,其实直接子类引用指向子类对象也可以用父类的东西,直接new 父类名()也可以,那引入继承干嘛,两者比较哪个更费事.