精华内容
下载资源
问答
  • c++,父类引用指向子类对象,虚函数

    千次阅读 2016-07-12 22:26:37
    c++,父类引用指向子类对象,虚函数

    #include<iostream.h>

    
    class Father
    {
    public:
    	Father()
    	{
    		f = 1;
    	}
    	
    	void print()
    	{
    		cout<<"f = "<<f<<endl;
    	}
    public:
    	int f;
    };

    #include<iostream.h>
    #include "Father.cpp"
    class Son : public Father
    {
    public:
    	Son():Father()
    	{
    		s = 2;
    	}
    
    	void print()
    	{
    		cout<<"s = "<<s<<endl;
    	}
    public:
    	int s;
    };
    
    int main()
    {
    	Son s;
    	s.print();//输出s = 2
    	Father& f = s;//这里如果直接用值,就是把“&”去掉,即使使用virtual也不会调用子类的方法,原因待解!
    	f.print();//输出父类 f=1
    
    	f = s;//父类引用指向子类对象
    	
    	f.print();//这里输出 f = 1;和java不一样,java里面则直接调用子类的方法,但是这里不是,这里调用的还是父类的,要让其自动调用子类的方法则需要将方法设置为虚函数,加关键字virtual
            ((Son&)f).print();//强制转换,输出 s = 2  
    
    	return 0;
    }
    展开全文
  • JAVA父类引用指向子类对象

    万次阅读 多人点赞 2018-07-24 21:07:31
    Java之所以引入多态的概念,原因之一就它在类的继承上的问题和C++不同,后者允许多继承,这确实给其带来了非常强大的功能,但是复杂的继承关系也给C++开发者带来了更大的麻烦,为了规避风险,Java只允许单继承,势必在功能...

    1.什么是多态?

    方法的重写、重载与动态连接构成多态性

    Java之所以引入多态的概念,原因之一就它在类的继承上的问题和C++不同,后者允许多继承,这确实给其带来了非常强大的功能,但是复杂的继承关系也给C++开发者带来了更大的麻烦,为了规避风险,Java只允许单继承,势必在功能上有很大的限制,所以,Java引入多态性的概念以弥补这点不足,此外,抽象类和接口也是解决单继承规定限制的重要手段.同时,多态也是面向对象编程的精髓所在.

    2.多态的体现

    1 接口 和 实现接口并覆盖接口中同一方法的几不同的类体现的

    2 父类 和 继承父类并覆盖父类中同一方法的几个不同子类实现的.

    子类覆盖父类实现多态:

        如果子类继承的超类是一个抽象类,虽然抽象类不能通过new操作符实例化,但是可以创建抽象类的对象引用指向子类对象,以实现运行时多态性,不过,抽象类的子类必须覆盖实现超类中的所有的抽象方法,否则子类必须被abstract修饰符修饰,当然也就不能被实例化了

    重写父类方法:

    //父类
    public class Father{
    //父类有一个打孩子方法
    	public void hitChild(){
    	}
    }
    //子类1
    public class Son1 extends Father{
    //重写父类打孩子方法
    	public void hitChild(){
    		System.out.println("为什么打我?我做错什么了!");
    	}
    }
    //子类2
    public class Son2 extends Father{
    //重写父类打孩子方法
    	public void hitChild(){
    		System.out.println("我知道错了,别打了!");
    	}
    }
    //子类3
    public class Son3 extends Father{
    //重写父类打孩子方法
    	public void hitChild(){
    		System.out.println("我跑,你打不着!");
    	}
    }
    
    //测试类
    public class Test{
    	public static void main(String args[]){
    		Father father;
    	
    		father = new Son1();
    		father.hitChild();
    	
    		father = new Son2();
    		father.hitChild();
    	
    		father = new Son3();
    		father.hitChild();
    	}
    }
    //重写父类打孩子方法
    	public void hitChild(){
    		System.out.println("我跑,你打不着!");
    	}
    }
    
    //测试类
    public class Test{
    	public static void main(String args[]){
    		Father father;
    	
    		father = new Son1();
    		father.hitChild();
    	
    		father = new Son2();
    		father.hitChild();
    	
    		father = new Son3();
    		father.hitChild();
    	}
    }
    

     

       Java里没有多继承,一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类,而在子类里可以重写父类的方法(例如方法print()),这样每个子类里重写的代码不一样,自然表现形式就不一样。这样用父类的变量去引用不同的子类,在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了,这就是多态,相同的消息(也就是调用相同的方法)会有不同的结果

     

    都调用了相同的方法,出现了不同的结果!这就是多态的表现!

     

    3.如何理解向上转型?

    我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类。我可以通过

    Cat c = new Cat();

    实例化一个Cat对象,这个不难理解。但当我这样定义时:

    Animal a = new Cat();

    这样代表什么意思呢?

    很简单,它表示我定义了一个Animal类型的引用,指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal,所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢?因为子类是对父类的一个改进和扩充,所以一般子类在功能上较父类更强大,属性较父类更独特:

        定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能,又可以抽取父类的共性。

    所以,父类类型的引用可以调用父类中定义的所有属性和方法,而对于子类中定义而父类中没有的方法,它是无可奈何的;

     

    对于父类中定义的方法,如果子类中重写了该方法,那么父类类型的引用将会调用子类中的这个方法,这就是动态连接。

    来我们举个栗子:

    class Father {
    	public void func1(){
    		func2();
    	} 
    	public void func2(){
    		System.out.println("AAA");
    	}
    }
    
    class Child extends Father{
    	
    	public void func1(int i){
    		System.out.println("BBB");
    		} 
    	
    	public void func2(){
    		System.out.println("CCC");
    		}
    	
    }
    
    
    public class Test {
    	public static void main(String[] args) {
    		
    		Father child = new Child();
    		child.func1();//打印结果将会是什么?
      }
    }
    

    上面的程序是个很典型的多态的例子。子类Child继承了父类Father,并重载了父类的func1()方法,重写了父类的func2()方法。重载后的func1(int i)和func1()不再是同一个方法,由于父类中没有func1(int i),那么,父类类型的引用child就不能调用func1(int i)方法。而子类重写了func2()方法,那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。

      经过上面的分析我们可以知道打印的结果是什么呢? 很显然,应该是"CCC"

    4.对于多态总结一下

        一、使用父类类型的引用指向子类的对象;

        二、该引用只能调用父类中定义的方法和变量;

        三、如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中       的这个方法;(动态连接、动态调用)

        四、变量不能被重写(覆盖),”重写“的概念只针对方法,如果在子类中”重写“了父       类中的变量,那么在编译时会报错。

    在现实生活中的体现:

          自己用自己的,儿子有父亲一样的,就用儿子的。省点钱是点。儿子独有的,父亲不会用,所以不能用

    5.站在内存分配的角度分析

        1.从对象的内存角度来理解. 

    假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,里面的变量需要占用0.5M内      存.   
        2.现在通过代码来看看内存的分配情况:

        f = new Father();//系统将分配1M内存.
        Son s = new Son();//系统将分配1.5M内存
    //系统将分配1M内存.
        Son s = new Son();//系统将分配1.5M内存
    

         因为子类中有一个隐藏的引用super会指向父类实例,所以在实例    化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用   父类的方法.
        3.

      

        Son s1 = s;//s1指向那1.5M的内存.
        Father f1 = (Father)s;//这时f1会指向那1.5M内存中的1M内存//s1指向那1.5M的内存.
        Father f1 = (Father)s;//这时f1会指向那1.5M内存中的1M内存

        即是说,f1只是指向了s中实例的父类实例对象,所以f1只能调用父类的方法(存储在1M内存中),而不能调用子类的方法(存储在0.5M内存中).
       

    Son s2 = (Son)f;//这句代码运行时会报ClassCastException.//这句代码运行时会报ClassCastException.

      因为f中只有1M内存,而子类的引用都必须要有1.5M的内存,所以无法转换.

    Son s3 = (Son)f1;//这句可以通过运行,这时s3指向那1.5M的内存.//这句可以通过运行,这时s3指向那1.5M的内存.

      由于f1是由s转换过来的,所以它是有1.5M的内存的,只是它指向的只有1M内存.

      所以可以实现强转...
        4.static   顾名思义,就是静态的,他是方法的,他属于这个类,由于是类的方法,他可以直接引用类名来引用方法,也可以通过类的对象来引用这个方法,他既不能被子类覆盖,也不能被子类继承。简单的说,他是在编译的时候就和类帮定在一起了,不能被运行时动态加载。

       对子类与父类的static问题
        ——没覆盖也没继承,子类存有指向父类的引用

        对于private
        ——该方法或属性只能在该类内使用

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • C++中,每个派生类对象都包含基类部分,所以可以将基类类型的引用绑定到派生类对象的基类部分,也可以用指向基类类型的指针指向派生类对象: #if 1 #include #include using namespace std; class Stu { public:...

    C++中,每个派生类对象都包含基类部分,所以可以将基类类型的引用绑定到派生类对象的基类部分,也可以用指向基类类型的指针指向派生类对象:

    #if 1
    #include <iostream>
    #include <string>
    using namespace std;
    
    class Stu
    {
    public:
    	Stu(const int num, const string& na): number(num), name(na){}
    	~Stu()
    	{}
    private:
    	int number;
    	string name;
    };
    
    class Graduate : public Stu
    {
    public:
    	Graduate(const int num, const string& na, const int ag):Stu(num, na), age(ag){}
    	~Graduate()
    	{}
    private:
    	int age;
    };
    
    int main()
    {
    	int number = 1001;
    	string aa("ddd");
    	Stu stud(1001, "ding");
    	Stu *student = &stud;
    	Graduate gra(1001,"wei", 20);
    
    	student = &gra;
    }
    
    #endif


     

    展开全文
  • Java的多态性面向对象编程有三个特征,即封装、继承和多态。封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。继承是为了重用父类代码,同时为实现多态性作准备。那么...

    Java的多态性

    面向对象编程有三个特征,即封装、继承和多态。

    封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。
    
    继承是为了重用父类代码,同时为实现多态性作准备。那么什么是多态呢?
    
    方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念,原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实给其带来的非常强大的功能,但是复杂的继承关系也给C++开发者带来了更大的麻烦,为了规避风险,Java只允许单继承,派生类与基类间有IS-A的关系(即“猫”is a “动物”)。这样做虽然保证了继承关系的简单明了,但是势必在功能上有很大的限制,所以,Java引入了多态性的概念以弥补这点的不足,此外,抽象类和接口也是解决单继承规定限制的重要手段。同时,多态也是面向对象编程的精髓所在。
    
    要理解多态性,首先要知道什么是“向上转型”。
    
    我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类。我可以通过
    

    Cat c = new Cat();
    实例化一个Cat的对象,这个不难理解。但当我这样定义时:

    Animal a = new Cat();
    这代表什么意思呢?

    很简单,它表示我定义了一个Animal类型的引用,指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal,所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢?因为子类是对父类的一个改进和扩充,所以一般子类在功能上较父类更强大,属性较父类更独特,
    

    定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能,又可以抽取父类的共性。

    所以,父类类型的引用可以调用父类中定义的所有属性和方法,而对于子类中定义而父类中没有的方法,它是无可奈何的;

    同时,父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下,才可以被父类类型的引用调用;

    对于父类中定义的方法,如果子类中重写了该方法,那么父类类型的引用将会调用子类中的这个方法,这就是动态连接。

    看下面这段程序:

    class Father{
    public void func1(){
    func2();
    }
    //这是父类中的func2()方法,因为下面的子类中重写了该方法
    //所以在父类类型的引用中调用时,这个方法将不再有效
    //取而代之的是将调用子类中重写的func2()方法
    public void func2(){
    System.out.println(“AAA”);
    }
    }

    class Child extends Father{
    //func1(int i)是对func1()方法的一个重载
    //由于在父类中没有定义这个方法,所以它不能被父类类型的引用调用
    //所以在下面的main方法中child.func1(68)是不对的
    public void func1(int i){
    System.out.println(“BBB”);
    }
    //func2()重写了父类Father中的func2()方法
    //如果父类类型的引用中调用了func2()方法,那么必然是子类中重写的这个方法
    public void func2(){
    System.out.println(“CCC”);
    }
    }

    public class PolymorphismTest {
    public static void main(String[] args) {
    Father child = new Child();
    child.func1();//打印结果将会是什么?
    }
    }
    上面的程序是个很典型的多态的例子。子类Child继承了父类Father,并重载了父类的func1()方法,重写了父类的func2()方法。重载后的func1(int i)和func1()不再是同一个方法,由于父类中没有func1(int i),那么,父类类型的引用child就不能调用func1(int i)方法。而子类重写了func2()方法,那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。

    那么该程序将会打印出什么样的结果呢?
    
    很显然,应该是“CCC”。
    
    对于多态,可以总结它为:
    

    一、使用父类类型的引用指向子类的对象;

    二、该引用只能调用父类中定义的方法和变量;
    
    三、如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法;(动态连接、动态调用)
    
    四、变量不能被重写(覆盖),”重写“的概念只针对方法,如果在子类中”重写“了父类中的变量,那么在编译时会报错。
    

    多态详解(整理)2008-09-03 19:29多态是通过:
    1 接口 和 实现接口并覆盖接口中同一方法的几不同的类体现的
    2 父类 和 继承父类并覆盖父类中同一方法的几个不同子类实现的.

    一、基本概念

    多态性:发送消息给某个对象,让该对象自行决定响应何种行为。
    通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

    java 的这种机制遵循一个原则:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。

    1. 如果a是类A的一个引用,那么,a可以指向类A的一个实例,或者说指向类A的一个子类。
    2. 如果a是接口A的一个引用,那么,a必须指向实现了接口A的一个类的实例。

    二、Java多态性实现机制

    SUN目前的JVM实现机制,类实例的引用就是指向一个句柄(handle)的指针,这个句柄是一对指针:
    一个指针指向一张表格,实际上这个表格也有两个指针(一个指针指向一个包含了对象的方法表,另外一个指向类对象,表明该对象所属的类型);
    另一个指针指向一块从java堆中为分配出来内存空间。

    三、总结

    1、通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

    DerivedC c2=new DerivedC();
    BaseClass a1= c2; //BaseClass 基类,DerivedC是继承自BaseClass的子类
    a1.play(); //play()在BaseClass,DerivedC中均有定义,即子类覆写了该方法

    分析:
    * 为什么子类的类型的对象实例可以覆给超类引用?
    自动实现向上转型。通过该语句,编译器自动将子类实例向上移动,成为通用类型BaseClass;
    * a.play()将执行子类还是父类定义的方法?
    子类的。在运行时期,将根据a这个对象引用实际的类型来获取对应的方法。所以才有多态性。一个基类的对象引用,被赋予不同的子类对象引用,执行该方法时,将表现出不同的行为。

    在a1=c2的时候,仍然是存在两个句柄,a1和c2,但是a1和c2拥有同一块数据内存块和不同的函数表。

    2、不能把父类对象引用赋给子类对象引用变量

    BaseClass a2=new BaseClass();
    DerivedC c1=a2;//出错

    在java里面,向上转型是自动进行的,但是向下转型却不是,需要我们自己定义强制进行。
    c1=(DerivedC)a2; 进行强制转化,也就是向下转型.

    3、记住一个很简单又很复杂的规则,一个类型引用只能引用引用类型自身含有的方法和变量。
    你可能说这个规则不对的,因为父类引用指向子类对象的时候,最后执行的是子类的方法的。
    其实这并不矛盾,那是因为采用了后期绑定,动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义,则会出错。
    例如,DerivedC类在继承BaseClass中定义的函数外,还增加了几个函数(例如 myFun())

    分析:
    当你使用父类引用指向子类的时候,其实jvm已经使用了编译器产生的类型信息调整转换了。
    这里你可以这样理解,相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了,所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。

    4、Java与C++多态性的比较

    jvm关于多态性支持解决方法是和c++中几乎一样的,
    只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中,但是利用某种技术来区别。

    Java把类型信息和函数信息分开放。Java中在继承以后,子类会重新设置自己的虚拟函数表,这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类自己的虚拟函数。
    虚拟函数调用是经过虚拟函数表间接调用的,所以才得以实现多态的。

            Java的所有函数,除了被声明为final的,都是用后期绑定。
    

    四. 1个行为,不同的对象,他们具体体现出来的方式不一样,
    比如: 方法重载 overloading 以及 方法重写(覆盖)override
    class Human{
    void run(){输出 人在跑}
    }
    class Man extends Human{
    void run(){输出 男人在跑}
    }
    这个时候,同是跑,不同的对象,不一样(这个是方法覆盖的例子)
    class Test{
    void out(String str){输出 str}
    void out(int i){输出 i}
    }
    这个例子是方法重载,方法名相同,参数表不同

               ok,明白了这些还不够,还用人在跑举例 
              Human ahuman=new Man(); 
              这样我等于实例化了一个Man的对象,并声明了一个Human的引用,让它去指向Man这个对象 
               意思是说,把 Man这个对象当 Human看了. 
    
               比如去动物园,你看见了一个动物,不知道它是什么, "这是什么动物? " "这是大熊猫! " 
               这2句话,就是最好的证明,因为不知道它是大熊猫,但知道它的父类是动物,所以, 
               这个大熊猫对象,你把它当成其父类 动物看,这样子合情合理. 
    
              这种方式下要注意 new Man();的确实例化了Man对象,所以 ahuman.run()这个方法 输出的   是 "男人在跑 " 
    
               如果在子类 Man下你 写了一些它独有的方法 比如 eat(),而Human没有这个方法, 
    

    在调用eat方法时,一定要注意 强制类型转换 ((Man)ahuman).eat(),这样才可以…

    对接口来说,情况是类似的…

    实例:

    package domatic;

    //定义超类superA
    class superA {
    int i = 100;

    void fun(int j) {
    j = i;
    System.out.println(“This is superA”);
    }
    }

    // 定义superA的子类subB
    class subB extends superA {
    int m = 1;

    void fun(int aa) {
    System.out.println(“This is subB”);
    }
    }

    // 定义superA的子类subC
    class subC extends superA {
    int n = 1;

    void fun(int cc) {
    System.out.println(“This is subC”);
    }
    }

    class Test {
    public static void main(String[] args) {
    superA a = new superA();
    subB b = new subB();
    subC c = new subC();
    a = b;
    a.fun(100);
    a = c;
    a.fun(200);
    }
    }
    /*
    * 上述代码中subB和subC是超类superA的子类,我们在类Test中声明了3个引用变量a, b,
    * c,通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问:
    * “为什么(1)和(2)不输出:This is superA”。
    * java的这种机制遵循一个原则:当超类对象引用变量引用子类对象时,
    * 被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,
    * 但是这个被调用的方法必须是在超类中定义过的,
    * 也就是说被子类覆盖的方法。
    * 所以,不要被上例中(1)和(2)所迷惑,虽然写成a.fun(),但是由于(1)中的a被b赋值,
    * 指向了子类subB的一个实例,因而(1)所调用的fun()实际上是子类subB的成员方法fun(),
    * 它覆盖了超类superA的成员方法fun();同样(2)调用的是子类subC的成员方法fun()。
    * 另外,如果子类继承的超类是一个抽象类,虽然抽象类不能通过new操作符实例化,
    * 但是可以创建抽象类的对象引用指向子类对象,以实现运行时多态性。具体的实现方法同上例。
    * 不过,抽象类的子类必须覆盖实现超类中的所有的抽象方法,
    * 否则子类必须被abstract修饰符修饰,当然也就不能被实例化了
    */
    以上大多数是以子类覆盖父类的方法实现多态.下面是另一种实现多态的方法———–重写父类方法

    1.JAVA里没有多继承,一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类,而在子类里可以重写父类的方法(例如方法print()),这样每个子类里重写的代码不一样,自然表现形式就不一样。这样用父类的变量去引用不同的子类,在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了,这就是多态,相同的消息(也就是调用相同的方法)会有不同的结果。举例说明:
    //父类
    public class Father{
    //父类有一个打孩子方法
    public void hitChild(){
    }
    }
    //子类1
    public class Son1 extends Father{
    //重写父类打孩子方法
    public void hitChild(){
    System.out.println(“为什么打我?我做错什么了!”);
    }
    }
    //子类2
    public class Son2 extends Father{
    //重写父类打孩子方法
    public void hitChild(){
    System.out.println(“我知道错了,别打了!”);
    }
    }
    //子类3
    public class Son3 extends Father{
    //重写父类打孩子方法
    public void hitChild(){
    System.out.println(“我跑,你打不着!”);
    }
    }

    //测试类
    public class Test{
    public static void main(String args[]){
    Father father;

       father = new Son1(); 
       father.hitChild(); 
    
       father = new Son2(); 
       father.hitChild(); 
    
       father = new Son3(); 
       father.hitChild(); 
    } 
    

    }
    都调用了相同的方法,出现了不同的结果!这就是多态的表现!

    展开全文
  • 父类指针或引用指向子类对象 假设我们现在有如下的类,其中Animal为基类,Cat和Dog都是其派生类。 class Animal{ public: virtual void speak(){ cout << "动物在说话" << endl; } }; class ...
  • 面向对象编程有三个特征,即封装、继承和多态。 封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。 继承是为了重用父类代码,同时为实现多态性作准备。那么什么...
  • 父类引用指向子类

    2016-10-14 22:40:50
    面向对象编程有三个特征,即封装、继承和多态。 封装隐藏了类的内部实现机制,从而可以在不影响使用者的前提下改变类的内部结构,同时保护了数据。 继承是为了重用父类代码,同时为实现多态性作准备。那么什么...
  • C++ 子类对象父类对象使用

    千次阅读 2017-11-15 15:35:20
    子类对象父类对象使用1⃣️把子类对象直接赋值给父类对象(等号左边是父类对象,等号右边是子类对象子类对象赋值给父类对象,仅仅把继承自父类部分成员函数赋值给父类对象 ...2⃣️父类引用指向子类
  • 4.父类指针可以直接指向子类对象 5.父类引用可以直接引用子类对象   以下是每一点的代码验证 1 子类对象可以直接赋值给父类对象 #include&lt;iostream&gt; using namespace std; class Parent { ...
  • 前文:C++之继承探究(四):继承的使用 把子类对象当作父类对象使用 分三种情况:   (1) 将子类对象赋值给父类对象。    ——把等号右边的子类对象,赋值给等号左边的父类...父类引用指向子类对象时,当通过父
  • 2. C++ 允许父类指针指向子类对象父类引用子类对象,无须通过强制类型转换保持赋值类型相容,因为子类对象isa父类对象,编译时按父类说明的权限访问成员; 3. 通过父类指针调用虚函数进行晚期绑定,根据对象的实际...
  • 文章目录1 C++继承中父类和子类之间的赋值兼容1.1 父子间的赋值兼容1.2 特殊的同名函数 1 C++继承中父类和子类...父类指针可以直接指向子类对象父类引用可以直接引用子类对象。 子类对象的兼容性: #include ...
  • C++子类指针指向父类

    千次阅读 2015-04-10 15:38:13
    1,直接用基类指针引用基类对象 2,直接用派生类指针引用派生类对象 3,用基类指针引用一个派生类对象,由于派生类对象也是基类的对象,所以这种引用是安全的, 但是只能引用基类成员。若试图通过基类指针引用...
  • 在实际开发的过程中,经常会遇到这种类似的问题,一个父类通常维护着属于该父类的多个子类指针,而每一个子类中也存储着指向父类的指针对象,方便进行节点递归或者其他操作。 比如说: 一个三维立方体,每一个三维...
  • 原文地址:关于C++子类指针指向父类.作者:leon  1,直接用基类指针引用基类对象 2,直接用派生类指针引用派生类对象 3,用基类指针引用一个派生类对象,由于派生类对象也是基类的对象,所以这种引用是安全...
  • 父类指针或者引用可以指向子类对象(指针解释的对象大小为基类大小,子类包含有基类) 子类分割成基类对象(一只鸡一定是一个动物) 以下二种情况不能成立: 子类指针或者引用指向父类对象(指针解释的对象大小...
  • 父类 子类

    千次阅读 2019-10-04 19:14:03
    C++ 允许,父类的指针直接指向子类对象,或者父类引用子类: #include<iostream> #include<stdio.h> #include<stdlib.h> using namespace std; class point{ ...
  • 原文地址:关于C++子类指针指向父类.作者:leon   1,直接用基类指针引用基类对象 2,直接用派生类指针引用派生类对象 3,用基类指针引用一个派生类对象,由于派生类对象也是基类的对象,所以这种引用是...
  • 父类子类间的继承关系 一、父类子类 父类子类的相互转换 1、派生类的对象可以赋给基类,反之不行 2、基类的指针可以指向派生类,反之不行 3、基类的引用可以初始化为派生类的对象,反之不行 4...
  • * 不同于C++,JAVA中指向子类对象的父型引用,依然优先调用子类对象的函数。C++相反。 * 不同于C++,JAVA中子类的构造函数自动调用父类的构造函数,若父类的构造函数中调用了方法,依然是子类优先。C++相反 */ ...
  • 3,用基类指针引用一个派生类对象,由于派生类对象也是基类的对象,所以这种引用是安全的, 但是只能引用基类成员。若试图通过基类指针引用那些只在派生类中才有的成员,编译器会报告语法错误。(解决该问题
  • 之前粗浅得了解了基类指针指向子类对象时,会舍弃子类所独有的那一部分。 直观地来看,这是通过解引用父类指针后,无法通过它来访问子类类成员变量,但可以通过虚函数表来调用子类重写的虚函数。这一部分可以搜很多...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 440
精华内容 176
关键字:

c++父类引用指向子类对象

c++ 订阅