#include <iostream.h> class Base { //基类 public: //int k; void fn1(){ cout<<"Base::fn1()"<<endl; } void fn2(){ cout<<"Base::fn2()"<<endl; } }; class Derived: public Base { //派生类 public: //int m; void fn1(){ cout<<"Derived::fn1()"<<endl; } void fn3(){ cout<<"Derived::fn3()"<<endl; } }; void main(){ Derived d; d.fn1(); d.fn2(); d.fn3(); }输出结果

输出结果应该是：

Derived::fn1()
Base::fn2()
Derived::fn3()

因为在派生类中重写了基类的 `fn1` 函数，所以调用 `d.fn1()` 时会调用派生类 `Derived` 中的函数；而 `fn2` 函数没有在派生类中重写，所以调用 `d.fn2()` 时会调用基类 `Base` 中的函数；`fn3` 函数是派生类 `Derived` 中新增的函数，调用 `d.fn3()` 时会直接调用该函数。

相关问题

定义一个基类BaseClass，从它派生出类DerivedClass，BaseClass 有成员函数fn1l()、fn2()，DerivedClass也有成员函数 fn1()、fn2()，在主程序中定义一个DerivedClass 的对象，分别用DerivedClass的对象以及BaseClass和 DerivedClass 的指针来调用fn1()、fn2()，观察运行结果。

好的，我来写一下这个程序的代码。首先是定义基类 BaseClass 和派生类 DerivedClass：

#include <iostream>

class BaseClass {
public:
    void fn1() {
        std::cout << "BaseClass::fn1()" << std::endl;
    }

    void fn2() {
        std::cout << "BaseClass::fn2()" << std::endl;
    }
};

class DerivedClass : public BaseClass {
public:
    void fn1() {
        std::cout << "DerivedClass::fn1()" << std::endl;
    }

    void fn2() {
        std::cout << "DerivedClass::fn2()" << std::endl;
    }
};

接下来是主程序部分：

int main() {
    DerivedClass obj;

    obj.fn1(); // 调用 DerivedClass::fn1()
    obj.fn2(); // 调用 DerivedClass::fn2()

    BaseClass* pBase = &obj;
    pBase->fn1(); // 调用 BaseClass::fn1()
    pBase->fn2(); // 调用 BaseClass::fn2()

    DerivedClass* pDerived = &obj;
    pDerived->fn1(); // 调用 DerivedClass::fn1()
    pDerived->fn2(); // 调用 DerivedClass::fn2()

    return 0;
}

在主程序中，我们先定义了一个 DerivedClass 的对象 obj，然后分别用对象和指针调用了 fn1() 和 fn2() 函数。其中，用 DerivedClass 对象调用 fn1() 和 fn2() 函数时，会分别调用 DerivedClass 中的同名函数；而用 BaseClass 和 DerivedClass 指针调用 fn1() 和 fn2() 函数时，会根据指针的类型来确定调用的函数，因为这两个函数都是虚函数，所以会根据对象的实际类型来调用相应的函数。因此，调用 BaseClass 指针的 fn1() 函数时，会调用 BaseClass 中的 fn1() 函数；调用 DerivedClass 指针的 fn1() 函数时，会调用 DerivedClass 中的 fn1() 函数；调用 BaseClass 指针和 DerivedClass 指针的 fn2() 函数时，都会调用 DerivedClass 中的 fn2() 函数。

定义一个基类BaseClass，有公有成员函数fn1()，fn2(),函数内打印出类名及函数名，有私有数据成员int i,从它派生出类DerivedClass,有公有成员函数fn1(),函数内打印出类名及函数名,私有数据成员int j,在主函数中分别用BaseClass及Derivedclass类的指针去调用fn1(),fn2，观察运行结果。要求： （1）注意派生类的构造函数须写正确； （2）分析通过指针调用成员函数的运行结果。

代码如下：

#include <iostream>
using namespace std;

class BaseClass {
public:
    void fn1() {
        cout << "BaseClass::fn1()" << endl;
    }
    void fn2() {
        cout << "BaseClass::fn2()" << endl;
    }
private:
    int i;
};

class DerivedClass : public BaseClass {
public:
    void fn1() {
        cout << "DerivedClass::fn1()" << endl;
    }
private:
    int j;
};

int main() {
    BaseClass *pb = new BaseClass;
    pb->fn1(); // BaseClass::fn1()
    pb->fn2(); // BaseClass::fn2()

    DerivedClass *pd = new DerivedClass;
    pd->fn1(); // DerivedClass::fn1()
    pd->fn2(); // BaseClass::fn2()

    delete pb;
    delete pd;
    return 0;
}

运行结果为：

BaseClass::fn1()
BaseClass::fn2()
DerivedClass::fn1()
BaseClass::fn2()

通过指针调用成员函数时，若派生类中有重写基类的成员函数，则会调用派生类中的成员函数，否则调用基类的成员函数。由于派生类并没有重写基类的fn2()函数，因此调用的是基类的fn2()函数。