C++ virtuelle Methode nicht wie erwartet aufgerufen

Question

Ich fummle herum mit richtigen Überschreiben von virtuellen Methoden. Ich kette einige Konstruktoren und im Basisklassenkonstruktor rufe ich eine virtuelle Methode auf.

Anrufkette sollte wie folgt sein:

B(p)->A(p)->B.foo(p) 

Call-Kette in C++:

B(p)->A(p)->A.foo(p) 

Call-Kette in C# ist:

B(p)->A(p)->B.foo(p) 

Also mit anderen Worten, in C# Verhalten ist wie erwartet, in C++ ist es nicht.

C++ Code:

#include <cstdio> 

class A { 
public: 
    A(); 
    A(int); 

    virtual void foo(int s); 
}; 

class B : public A { 
public: 
    B(); 
    B(int s) : A(s) {}; 

    virtual void foo(int s) override; 
}; 

A::A() { 
    std::printf("A\r\n"); 
}; 

A::A(int s) : A() { 
    std::printf("A: %d\r\n", s); 
    foo(s); 
}; 

void A::foo(int s) { 
    std::printf("A::foo(%d)\r\n", s); 
} 

B::B() : A(){ 
    std::printf("B\r\n"); 
}; 

void B::foo(int s) { 
    std::printf("B::foo(%d)\r\n", s); 
} 

int main(int argc, char* argv[]) { 
    B b(2); 
} 

Ausgang:

A 
A: 2 
A::foo(2) 

C# Code:

using System; 

namespace demo { 
class A{ 
    public A() { 
    Console.WriteLine("A"); 
    } 

    public A(int s) : this(){ 
    Console.WriteLine("A: " + s.ToString()); 
    foo(s); 
    } 

    public virtual void foo(int s) { 
    Console.WriteLine(string.Format("A:foo({0})", s)); 
    } 
} 

class B : A{ 
    public B() : base() { 
    Console.WriteLine("B"); 
    } 

    public B(int s) : base(s) { 
    } 

    public override void foo(int s) { 
    Console.WriteLine(string.Format("B:foo({0})", s)); 
    } 
} 

    static class Run { 
    static void Main() { 
     new B(2); 
    } 
    } 
} 

Ausgang:

A 
A: 2 
B::foo(2) 

Warum wird in C++ nicht die überschriebene Methode der Klasse B aufgerufen? Wie muss ich es richtig überschreiben?

Answer 1

So funktioniert C++. Virtuelle Funktionen verhalten sich während der Konstruktion und der Zerstörung von Objekten nicht virtuell.