我认为,你需要张贴一些法典,以澄清你要求的内容,但(除校长外)除非儿童明确要求其履行自己的职责,否则不会叫上基础职能。 例如:

struct A {
    virtual ~A() {}
    virtual void f() {}
};

struct B : public A {
    virtual void f() {}
};

int main() {
    A * a = new B;
    a->f();
    delete a;
}

只有B的虚拟功能 f()被点名。 如果你想要A:f()要求你明确:

struct B : public A {
    virtual f() { 
       A::f();    // explicit call
    }
};

在B没有宣布职能的情况下,当然还有奥赫,在这种情况下,A:f()总是被叫来。

不可能理解问题在目前形式中的确切含义。

如果从字面上讲,问题有明显和立即的答案:如果父母的履行是有关职能的最终压倒者,即儿童没有执行自己的职责,则要求父母的版本。

class parent {
public:
  virtual void foo() { /* whatever */ }
};

class child : parent {
public:
  void bar() {
    foo(); /* call the parent s implementation, as requested */
  }
};

因此,请你回答。

当然,对任何人来说,这种解释是显而易见的,他们很可能不是问题所暗示的。 很可能意味着子女阶级优先于父母的职能。 在该案中,还有另一个明显的答案:如果儿童使用完全合格的职务名称,将叫作母体。

class parent {
public:
  virtual void foo() { /* whatever */ }
};

class child : parent {
public:
  virtual void foo() { /* whatever */ }
  void bar() {
    parent::foo(); /* call the parent s implementation, as requested */
  }
};

另一种可能的答案是,被称之为功能的物体实际上有<条码>。

class parent {
public:
  virtual void foo() { /* whatever */ }
};

class child : parent {
public:
  virtual void foo() { /* whatever */ }
  void bar() {
    parent p;
    p.foo(); /* call the parent s implementation, as requested */
  }
};

同样,它认为,这不是问题。 很可能,问题在于建筑商和司机发出的虚拟电话。

class parent {
public:
  parent() { 
    foo(); /* always calls `parent::foo` */
  }
  virtual void foo() { /* whatever */ }
};

class child : parent {
public:
  child() : parent() /* `parent::parent` will call `parent::foo` */
    {}
  virtual void foo() { /* whatever */ }
};

然而,由于这一问题的措辞不正确。 在发出呼吁时的最后一个例子中,还没有儿童目标。 它的记忆已经分配,但其寿命尚未开始。 说虚拟功能的电话由儿童对象履行是不正确的。 系由母物体执行。

因此,为了恢复上述工作:问题措辞模糊不清,措辞模糊不清,没有意义。

• When the base class s scope is explicitly used ( Base::f(); )
• Inside the base class s constructor (because the derived object s constructor hasn t been entered yet)
• Inside the base class s destructor (because the derived object has already been destructed)

如果这一举动是想方的,则发送将是静态的。 http://cplus.co.il/2009/09/30/virtual-dissuing-within-a-ructor-or-a-destructor/“rel=“nofollow noreferer”>http://cplus.co.il/2009/09/30/virtual-dispading-within-a-ructor-or-a-destructor/

struct A {
    A () { f(); }
    virtual void f () { }
};

struct B : A {
        B () :member(0) {}
        void f () { std::cout << member; }
    private:
        int member;
};

int main () {
    B b;
    return 0;
}

http://support.microsoft.com/kb/125749”rel=“nofollow noreferer”>http://support.microsoft.com/kb/125749

   class A;

   void fcn( A* );

   class A
   {
   public:
       virtual void f() = 0;
       A() { fcn( this ); }
   };

   class B : A
   {
       void f() { }
   };

   void fcn( A* p )
   {
       p->f();
   }

   // The declaration below invokes class B s constructor, which
   // first calls class A s constructor, which calls fcn. Then
   // fcn calls A::f, which is a pure virtual function, and
   // this causes the run-time error. B has not been constructed
   // at this point, so the B::f cannot be called. You would not
   // want it to be called because it could depend on something
   // in B that has not been initialized yet.

   B b;

   void main()
   {
   }