C++ 笔试题 虚函数， 难

[languagec]

#include <iostream>
#include <string>
using namespace std;

void println(const std::string& msg)
{
std:cout<<msg<<'\n';
}

class Base{
public:
Base() {
println("Base::Base()");
Virt();
}
void f(){
println("Base::f()");
Virt();
}
virtual void Virt(){
println("Base()::virt()");
}
};

class Derived:public Base
{
public:
Derived(){
println("Derived:: Derived ()");
Virt();
}

virtual void Virt(){
println("Derived ()::virt()");
}
};

int main(int argc,char* argv[])
{
Derived d;
Base *pB=&d;
pB->f();
}


输出结果是
Base::Base()
Base()::virt()
Derived:: Derived ()
Derived ()::virt()

Base::f()
Derived ()::virt()


为什么？

[LeonTown]

f()函数是普通的继承，
而Virt()函数才是多态

[pady_pady]

[Quote=引用 1 楼 akirya 的回复:]
不要在构造函数中调用虚函数
[/Quote]
顶下，

[高性能架构探索]

int main(int argc,char* argv[]) 
{ 
    Derived d; 
    Base *pB=&d; 
    pB->f(); 
} 

Base::Base() 
Base()::virt() 
Derived:: Derived () 
Derived ()::virt() 
/*上述结果出现的原因：由于创建一个派生类对象，所以先调用基类构造函数，那么输出是
Base::Base() 
Base()::virt() ，然后调用派生类构造函数，输出结果为Derived:: Derived () 
Derived ()::virt() */
Base::f() 
Derived ()::virt() 
/*由于f()为基类特有，所以输出有Base::f() ,而virt()为虚函数，此时调用派生类中的virt()*/

[benbshmily]

Base::Base()
Base()::virt()
Derived:: Derived ()
Derived ()::virt()

以上是Derived d; 定义对象d是调用构造函数时打印的结果，这个只要知道构造函数调用顺序就ok。
Base *pB=&d;
pB->f();
这样基类的指针指向派生类对象后，调用f函数时传入的this指针是指向d的，因此在f函数里调用virt() 函数时就调用到了派生类的版本，常见的多态瑟。所以打印出下面结果。

Base::f()
Derived ()::virt()

个人感觉不难.......

[zhangyinze123]

基类中的虚函数，由派生类实现！
函数的多态性

[rabbitlzx]

[Quote=引用 7 楼 benbshmily 的回复:]
Base::Base()
Base()::virt()
Derived:: Derived ()
Derived ()::virt()

以上是Derived d; 定义对象d是调用构造函数时打印的结果，这个只要知道构造函数调用顺序就ok。
Base *pB=&d;
    pB->f();
这样基类的指针指向派生类对象后，调用f函数时传入的this指针是指向d的，因此在f函数里调用virt() 函数时就调用到了派生类的版本，常见的多态瑟。所以打印出下面结果。

Base::f()
Derived ()::virt()

个人感觉不难.......
[/Quote]

up

[macrojj]

主要是 f()不是虚函数 然后 virt（）是虚函数。
你可以这样想。virt 是this 指针调用的。 所以在虚函数寻址的时候，查的是派生类的虚函数表，所以找到了派生类的virt 。

[qiuyatao]

[Quote=引用楼主 languagec 的回复:]
#include <iostream>
#include <string>
using namespace std;

void println(const std::string& msg)
{
    std:cout < <msg < <'\n';
}

class Base{
    public:
    Base() {
        println("Base::Base()");
        Virt();
    }
    void f(){
        println("Base::f()");
        Virt();
    }
    virtual void Virt(){
        println("Base()::virt()");
    }
};

class Derived:public Base
{
public:
    Derived(){
        println("Derived:: Derived ()");
        Virt();
    }

    virtual void Virt(){
        println("Derived ()::virt()");
    }
};

int main(int argc,char* argv[])
{
    Derived d;
    Base *pB=&d;
    pB->f();
}


输出结果是
Base::Base()
Base()::virt()
Derived:: Derived ()
Derived ()::virt()

Base::f()
Derived ()::virt()


为什么？

[/Quote]

看到这个题我突然想请教高手另一个问题，在主函数Derived d;的时候，在d调用构造函数的时候Derived的对象还没生成，也就是d还没完全生成。此时调用Virt();的话this指针不是应该指向基类吗？请高手指点！谢谢

[J10FX]

子类创建一个对象的时候会首先调用基类的构造函数然后在调用本类的构造函数，这样以来对象才算建立，你要想实现多态的话，那么基类的虚函数和子类的虚函数一定要一致

[lovesi3344]

好问题

[wangxipu]

牛
一点不实用的题目
构造函数里面调用虚函数

[macrojj]

[Quote=引用 11 楼 qiuyatao 的回复:]
引用楼主 languagec 的回复:
#include <iostream>
#include <string>
using namespace std;

void println(const std::string& msg)
{
    std:cout < <msg < <'\n';
}

class Base{
    public:
    Base() {
        println("Base::Base()");
        Virt();
    }
    void f(){
        println("Base::f()");
        Virt();
    }
    virtual void Virt(){
        println("Base()::virt()");
    }
};

class Derived:public Base
{
public:
    Derived(){
        println("Derived:: Derived ()");
        Virt();
    }

    virtual void Virt(){
        println("Derived ()::virt()");
    }
};

int main(int argc,char* argv[])
{
    Derived d;
    Base *pB=&d;
    pB->f();
}


输出结果是
Base::Base()
Base()::virt()
Derived:: Derived ()
Derived ()::virt()

Base::f()
Derived ()::virt()


为什么？



看到这个题我突然想请教高手另一个问题，在主函数Derived d;的时候，在d调用构造函数的时候Derived的对象还没生成，也就是d还没完全生成。此时调用Virt();的话this指针不是应该指向基类吗？请高手指点！谢谢
[/Quote]

是啊。。。所以结果的前两个是：
Base::Base()
Base()::virt()

[机智的呆呆]

像上面构造函数中的虚函数是静态绑定的。

[zhangjie199011087]

没有意思啊！

[jhony_lee]

[Quote=引用 1 楼 akirya 的回复:]
不要在构造函数中调用虚函数
[/Quote]
顶一下

[xinjiXJZ]

~~~~

[lxfhfut]

其实只要知道 在构造函数中调用的虚函数不具有多态性，而在普通成员函数或其他函数中直接调用虚函数是具有多态性的。。。

[yyc23]

这个题目考察两点：
第一：在构造函数中调用虚函数，那么虚拟机制就不会发生作用，也就是不能实现多态性。
究其原因是基类的构造函数执行时，派生类的数据成员还未初始化，虚函数不能向下匹配到派生类，因此执行的还是基类的虚函数。
第二：基类的指针指向派生类的对象，基类指针调用其成员函数体中有调用虚函数，那么也能实现多态，只不过不是直接调用虚函数罢了。

[bvbook]

顶


求职面试，可以看《编程之美——微软技术面试心得》

[yyc23]

顶上