精华内容
下载资源
问答
  • 在cpp中,如果使用父类指针实例化一个对象,在调用时是不可以调用子类成员函数的,如果想要调用子类函数,可以这样操作。 class Father{ public: virtual void Func(){ std::cout<<"base fuction"<<...

    在cpp中,如果使用父类指针实例化一个对象,在调用时是不可以调用子类成员函数的,如果想要调用子类函数,可以这样操作。

    class Father{
     public:
      virtual void Func(){
          std::cout<<"base fuction"<<std::endl;
      };
    };
    
    class Son : public Father{
     public:
      void Func(){
          std::cout<<"son base "<<std::endl;
      }
      void NewFunc(){
          std::cout<<"son new func "<<std::endl;
      }
    };
    

    实例化一个父类指针:

        std::unique_ptr<Father> object = std::unique_ptr<Father>(new Son());
        object->NewFunc();//illegal
    

    object->NewFunc()是会报错的。
    要实现这个需要使用dynamic_cast
    示意:

        dynamic_cast<Son *>(object.get())->NewFunc();  //legal
    
    展开全文
  • 利用多态机制,一个指向子类的父类指针或引用,当调用被子类重写的虚函数时,实际上调用的是子类函数,这是通过多态的方式来实现父类调用子类,该方法需要一个引用或者指针调用虚函数来实现。如下面所示: Class ...

    父子类关系

    对于继承关系中的父类和子类,我们可以说子类是父类的一种,子类继承了父类的属性和行为。因此,子类可以访问父类的所有非私有成员。相反,父类一般情况下是不能访问子类成员的。然而,我们可以通过一些方法间接的实现父类访问子类,即父类函数访问子类函数。

    方法一

    利用多态机制,一个指向子类的父类指针或引用,当调用被子类重写的虚函数时,实际上调用的是子类函数,这是通过多态的方式来实现父类调用子类,该方法需要一个引用或者指针调用虚函数来实现。如下面所示:

    Class Base
    {
    public:
        virtual void fun()
        {
            std::cout << "Base::fun()" << std::endl;
        }
    };
    
    class Derived : public Base
    {
    public:
        virtual void fun()
        {
            std::cout << "Derived::fun()" << std::endl;
        }
    };
    
    Base* base = new Derived;
    base->fun();    //该结果输出为: "Derived::fun()"

    上面简单的例子就是通过多态实现的父类调用子类成员函数,这里面必须要有虚函数,并且在子类里面重写。

    方法二

    通过函数指针同样可以实现父类函数访问子类函数,示例代码如下:

    class Base
    {
    public:
        typedef void (Base::*pfn)();
    
        void CallFunction()
        {
            if(fn != NULL)
            {
                (this->*fn)();  //调用Derived类中的fun()函数
            }
        }
        void SetPfn(pfn fn)
        {
            this->fn = fn;
        }
    
    private:
        pfn fn;
    
    };
    
    class Derived : public Base
    {
    public:
        void Init()
        {
            SetPfn((pfn)&Derived::fun);
        }
    
        void fun()
        {
            std::cout << "Derived::fun be called in Base function!" << std::endl;
        }
    
    };
    
    Derived derived;
    derived.Init();
    derived.CallFunction();//这里调用的是父类的成员函数,该函数通过函数指针调用了子类的普通成员函数,调用结果输出:"Derived::fun be called in Base function!",即父类成员函数调用了子类成员函数。
    
    

    程序执行结果如下:

    这里写图片描述

    展开全文
  • 父子类关系对于继承关系中的父类和子类,我们可以说...方法一利用多态机制,一个指向子类的父类指针或引用,当调用被子类重写的虚函数时,实际上调用的是子类函数,这是通过多态的方式来实现父类调用子类,该方法需要一

    父子类关系

    对于继承关系中的父类和子类,我们可以说子类是父类的一种,子类继承了父类的属性和行为。因此,子类可以访问父类的所有非私有成员。相反,父类一般情况下是不能访问子类成员的。然而,我们可以通过一些方法间接的实现父类访问子类,即父类函数访问子类函数。

    方法一

    利用多态机制,一个指向子类的父类指针或引用,当调用被子类重写的虚函数时,实际上调用的是子类函数,这是通过多态的方式来实现父类调用子类,该方法需要一个引用或者指针调用虚函数来实现。如下面所示:

    Class Base
    {
    public:
        virtual void fun()
        {
            std::cout << "Base::fun()" << std::endl;
        }
    };
    
    class Derived : public Base
    {
    public:
        virtual void fun()
        {
            std::cout << "Derived::fun()" << std::endl;
        }
    };
    
    Base* base = new Derived;
    base->fun();    //该结果输出为: "Derived::fun()"

    上面简单的例子就是通过多态实现的父类调用子类成员函数,这里面必须要有虚函数,并且在子类里面重写。

    方法二

    通过函数指针同样可以实现父类函数访问子类函数,示例代码如下:

    class Base
    {
    public:
        typedef void (Base::*pfn)();
    
        void CallFunction()
        {
            if(fn != NULL)
            {
                (this->*fn)();  //调用Derived类中的fun()函数
            }
        }
        void SetPfn(pfn fn)
        {
            this->fn = fn;
        }
    
    private:
        pfn fn;
    
    };
    
    class Derived : public Base
    {
    public:
        void Init()
        {
            SetPfn((pfn)&Derived::fun);
        }
    
        void fun()
        {
            std::cout << "Derived::fun be called in Base function!" << std::endl;
        }
    
    };
    
    Derived derived;
    derived.Init();
    derived.CallFunction();//这里调用的是父类的成员函数,该函数通过函数指针调用了子类的普通成员函数,调用结果输出:"Derived::fun be called in Base function!",即父类成员函数调用了子类成员函数。
    
    

    程序执行结果如下:

    这里写图片描述

    展开全文
  • 父类对象指针调用子类函数

    千次阅读 2020-02-10 11:35:25
    父类中声明某个函数为虚函数,并且子类得载了这个虚函数以后,用父类对象的指针可以调用子类的相应函数,但前提是该指针指向的对象是子类的对象,否则没有意义。 1.新建一个子类对象时,它首先执行它父类的构造...

    当父类中声明某个函数为虚函数,并且子类得载了这个虚函数以后,用父类对象的指针可以调用子类的相应函数,但前提是该指针指向的对象是子类的对象,否则没有意义。

    1.新建一个子类对象时,它首先执行它父类的构造方法然后再执行子类的构造方法。

    2.我们new一个子类对象赋给父类(父类的引用指向了子类的对象,也就是说java里说的多态,),父类对象不可以调用子类的方法,但如果子类重写了父类的某个方法,则此时父类调用的是子类方法的内容。

    
    //
    class A
    {
    public:
    
    virtual int a();
    
    }
    
    //
    class B:A
    
    {
        int a()
        {
            printf("");
        }
    
    }
    
    
    
    
    
    //多态
    class C 
    {
        A* m_pA;
        m_pA = new B();
        
    //调用B类的方法
        m_pA-> a();
    
    
    }

     

    展开全文
  • 父类指针指向子类实例,用父类指针调用函数,调用的是子类函数还是父类的函数 以下程序的显示结果是什么,为什么 #include <iostream>using namespace std; class CParent{public: ...
  • 一、父类指针指向子类对象 先上代码: class Base { public: void base_fun1() {} virtual void base_fun2() { cout << "this is Base fun2()" << endl; } public: int a_a; protected: int a...
  • 而调用被子类重写虚函数时,会调用子类中的函数。 这是因为子类中被重写的虚函数的运行方式是动态绑定的,与当前指向类实例的父类指针类型无关,仅和类实例对象本身有关。 静态绑定发生在编译期,动态绑定发生在...
  •  其实这块我们需要分为两种情况来考虑,第一种是类继承(静态绑定),第二种是父类中包含虚函数(动态绑定)。 2 具体实现 2.1 没有虚函数的继承  如果以一个基础类指针指向一个派生类对象,那么经由该指针只能...
  • 简而言之就是用父类型的指针指向其子类的实例,然后通过父类指针调用实际子类的成员函数。但仅仅可调用父类含有的函数,非父类函数不能调用。 普通虚函数调用 假设我们有下面的类层次: #include &lt;...
  • C++子类父类成员函数的覆盖和隐藏实例详解 函数的覆盖  覆盖发生的条件: (1) 基类必须是虚函数(使用virtual 关键字来进行声明) (2)发生覆盖的两个函数分别位于派生类和基类 (3)函数名和参数列表必须完全...
  • Identity是一个基类,用于下面子类继承 给指针赋值 如果只是使用manager->,调用出来的也仅仅就是基类中的各个属性,其他会隐藏起来 将父类指针转为子指针,就可以调用子类其他接口 ...
  • A是父类,B是A的子类,B重载了A的void foo()方法,但是B把foo()做成私有方法 A的指针指向B的实例,调用foo(),得到输出B OUT struct A { virtual void foo() { cout << "A OUT" << endl; } }; ...
  • 即:没有虚函数的继承:如果一个基础类(父类)指针指向派生类(子类),那么该指针只能调用基础类(父类)定义的函数(如果子类重写了函数,那么因为定义的是父类指针掉的将会是父类的函数,即根据指针的原型来确定...
  • // 方法1:虚构函数 //virtual ~AnimalC() //{ // cout << "call ~AnimalC(虚析构函数)" << endl; //} // 方法2 纯虚析构函数,!!! 除了声明外还需要在外部写函数体 !!!!! .
  • 父类指针指向子类对象 :  父类指针指向子类对象中的父类对象; 一个多继承问题:  class Base{}; class A : public Base {}; class B : public Base {}; class C : public A , public B {}; int main(int ar...
  • 这是因为,父类指针p和子类指针c(加入inti之后),两个类所占的内存大小也不一样了,指针的数据类型是他所指向的内存空间的数据类型,因此p指针自加1的大小为一个父类对象的内存大小,而c指针自加1的大小为一个子类...
  • c++ 父类指针如何操作子类的新函数

    千次阅读 2016-10-20 19:50:58
    父类指针无法直接调用子类的新函数,需要转换为子类的指针后方可调用。  C++编译器在编译的时候是做静态类型分析。也就是说,你的父类指针是否真的指向一个子类类型,编译器并不会做这个假设。所以你用...
  • 结论:父类指针可以指向子类对象,但是只能访问父类成员,不能访问子类成员 结论:子类指针不可以指向父类对象,需要类型转换才可以 笔记: <1>.当基类指针指向派生类的时候,只能操作派生类从基类中继承...
  • class A {public:A() { printf("A \n"); }~A() { printf(" ~A \n");...因为这个例子是B*指针指向B对象,不是A*指针指向B对象。}; class B : public A{public:B() { printf("B \n"); }~B() { printf("~B \...
  • class A ...而调用被子类重写虚函数时,会调用子类中的函数。 再次说明了,子类中被重写的虚函数的运行方式是动态绑定的,与当前指向类实例的父类指针类型无关,仅和类实例对象本身有关。
  • 一:基类指针子类指针 在这里插入代码片 二:虚函数 在这里插入代码片 c++11引入的override与final关键字在虚函数中的...说明:override只能在子类中使用,而final只能在父类中使用,并且是只能用在虚函数上。 ...
  • 其实这个问题的原理很简单,delete就是释放堆上对象,它删除一个对象的时候,从指针pb开始,到sizeof(B)结束,记住,这时候是sizeof(B),调用B的析构函数,B的析构函数是虚函数,根据多态性,就先调用D的析构函数,...
  • 文章目录虚析构函数父类指针指向子类对象||子类指针指向父类对象总结: 虚析构函数 《Effective C++ 》 当派生类(derived class)对象由一个基类(base class)指针删除时,若基类有一个非虚函数(non-virtual)...
  • 父类子类指针函数调用注意事项 1,如果以一个基础类指针指向一个衍生类对象(派生类对象),那么经由该指针只能访问基础类定义的函数(静态联翩) 2,如果以一个衍生类指针指向一个基础类对象,必须先做强制转型动作...
  • #include &lt;iostream&gt; using namespace std; class A //基类 { protected: ... //虚析构函数 }; A::A(int l) { cout &lt;&lt; "AAAAAAAAAAAAAAAAA" &lt;&...
  • 但是在子类虚函数的定义中确可以调用子类的任何成员。我是这么认为的父类的指针指向子类对象时候在内存上已经初始化了子类对象所有成员的值,但是应为p是父类指针只能访问关于子类继承与父类的成员。当虚函数调用时...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,134
精华内容 31,653
关键字:

父类指针调用子类函数