#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(); }输出结果
时间: 2024-03-04 22:49:12 浏览: 74
输出结果应该是:
```
Derived::fn1()
Base::fn2()
Derived::fn3()
```
因为在派生类中重写了基类的 `fn1` 函数,所以调用 `d.fn1()` 时会调用派生类 `Derived` 中的函数;而 `fn2` 函数没有在派生类中重写,所以调用 `d.fn2()` 时会调用基类 `Base` 中的函数;`fn3` 函数是派生类 `Derived` 中新增的函数,调用 `d.fn3()` 时会直接调用该函数。
相关问题
声明一个基类BaseClass,从它派生出类DerivedClass。 (1)基类BaseClass有成员函数fn1()和fn2(),fn1()是虚函数。 (2)派生类DerivedClass也有成员函数fn1()和fn2()。 (3)在main()主函数中声明一个DeriveClass的对象,分别用BaseClass和DerivedClass类型的指针指向该DerivedClass的对象,并通过指针调用fn1()和fn2(),编译程序并观察运行结果,解释程序执行原理。
好的,我会记录下您的问题并回答。以下是代码示例:
```c++
#include <iostream>
using namespace std;
class BaseClass {
public:
virtual void fn1() {
cout << "BaseClass fn1 called." << endl;
}
void fn2() {
cout << "BaseClass fn2 called." << endl;
}
};
class DerivedClass : public BaseClass {
public:
void fn1() {
cout << "DerivedClass fn1 called." << endl;
}
void fn2() {
cout << "DerivedClass fn2 called." << endl;
}
};
int main() {
DerivedClass obj;
BaseClass* ptr1 = &obj;
DerivedClass* ptr2 = &obj;
ptr1->fn1(); // 调用 DerivedClass::fn1(),因为 fn1() 是虚函数
ptr1->fn2(); // 调用 BaseClass::fn2(),因为 fn2() 不是虚函数
ptr2->fn1(); // 调用 DerivedClass::fn1()
ptr2->fn2(); // 调用 DerivedClass::fn2()
return 0;
}
```
在这个示例中,我们定义了一个基类 `BaseClass` 和一个派生类 `DerivedClass`。在 `BaseClass` 中定义了一个虚函数 `fn1()` 和一个非虚函数 `fn2()`,在 `DerivedClass` 中重写了 `fn1()` 和 `fn2()`。在 `main()` 中创建了一个 `DerivedClass` 对象,并使用 `BaseClass` 和 `DerivedClass` 类型的指针指向该对象,并通过指针调用了 `fn1()` 和 `fn2()`。
由于 `fn1()` 是虚函数,在 `BaseClass` 和 `DerivedClass` 中都有定义,因此在调用时会根据指针指向的对象的实际类型来决定调用哪个版本的 `fn1()`。当指针为 `BaseClass*` 类型时,调用的是 `DerivedClass` 中重写后的 `fn1()`;当指针为 `DerivedClass*` 类型时,调用的也是 `DerivedClass` 中重写后的 `fn1()`。
而 `fn2()` 不是虚函数,无论指针的类型是什么,都会调用指向的类型中定义的版本。当指针为 `BaseClass*` 类型时,调用的是 `BaseClass` 中定义的 `fn2()`;当指针为 `DerivedClass*` 类型时,调用的是 `DerivedClass` 中定义的 `fn2()`。
因此,C++ 中的多态需要使用虚函数来实现,只有将基类的函数声明为虚函数,才能正确地调用派生类中的函数。
定义一个基类BaseClass,从它派生出DerivedClass, BaseClass有成员函数fn1()、fn2(),DerivedClass也有成员 函数fn1()、fn2(),在主函数中声明一个DerivedClass的对 象,分别 用DerivedClass的对象以及BaseClass和 DerivedClass的指针来调用fn1()、fn2(),观察运行结果。
好的,以下是代码实现:
```c++
#include <iostream>
using namespace std;
class BaseClass {
public:
void fn1() {
cout << "BaseClass::fn1()" << endl;
}
void fn2() {
cout << "BaseClass::fn2()" << endl;
}
};
class DerivedClass : public BaseClass {
public:
void fn1() {
cout << "DerivedClass::fn1()" << endl;
}
void fn2() {
cout << "DerivedClass::fn2()" << endl;
}
};
int main() {
DerivedClass obj;
BaseClass *p1 = &obj;
DerivedClass *p2 = &obj;
obj.fn1();
obj.fn2();
p1->fn1();
p1->fn2();
p2->fn1();
p2->fn2();
return 0;
}
```
运行结果如下:
```
DerivedClass::fn1()
DerivedClass::fn2()
BaseClass::fn1()
BaseClass::fn2()
DerivedClass::fn1()
DerivedClass::fn2()
```
从结果可以看出,当直接使用DerivedClass的对象调用函数时,会调用DerivedClass中的函数;当使用BaseClass的指针来调用函数时,会调用BaseClass中的函数;当使用DerivedClass的指针来调用函数时,会先在DerivedClass中寻找对应的函数,如果没有则会去BaseClass中寻找。这是因为DerivedClass继承了BaseClass的成员函数,但是在DerivedClass中对这些函数进行了重载。
阅读全文
相关推荐
















