C++--多态--重载、虚函数、隐藏的比较（二版）

Gosolo！

已于 2023-03-10 16:21:07 修改

阅读量138

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

于 2022-10-16 16:11:41 首次发布

本文链接：https://blog.csdn.net/qq_68741368/article/details/127348116

版权

C++ 专栏收录该内容

43 篇文章 2 订阅

订阅专栏

多态

概念

多态：多种形态。去完成某个行为，不同的对象会产生不同的结果。

这里以买票为例，学生买票，成人买票，军人买票。多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。Student继承了 Person。Person对象买票全价，Student对象买票半价。

构成多态的条件

1.通过父类的指针或引用调用虚函数。

2.虚函数重写。

虚函数

在函数声明的返回值前加virtual 就是虚函数

必须是成员函数才可以带virtual

class Person 
{
public:
    virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

当一个类的某个函数被说明为 virtual ，则在该类的所有派生类中的同原型函数都是虚函数

虚函数的重写

子类中有一个跟父类完全相同的虚函数(返回值类型、函数名字、参数列表完全相同)。

注：不符合重写才是隐藏关系。

class Person
{
public:
    virtual void Buyticket()
    {
        cout<<"买票--全价"<<endl;
    }
};
class Student :public Person
{
public:
    virtual void Buyticket()
    {
        cout<<"买票--半价"<<endl;
    }
};
void Func(Person& p)
{
    p.Buyticket();
}
int main()
{
    Person a;
    Student b;
    Func(a);
    Func(b);
    return 0;
}

虚函数重写的两个特例

1.如果父基的析构函数为虚函数，此时子类析构函数只要定义，无论是否加virtual关键字，都与父类的析构函数构成重写。编译器对析构函数做了特殊处理，统一析构函数名字为destructor。

子类虚函数不加virtual，依旧构成重写。（ps:最好加上）

析构函数重写的意义

释放父类指针时能正确释放子类对象，指向的对象是谁，就调用谁的析构函数。

class Person {
public:
 virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person {
public:
 virtual ~Student() { cout << "~Student()" << endl; }
};

2.重写的协变。返回值可以不同，但必须是父子关系的指针或引用。任意父子关系即可

class A{};
class B:public A{};

class Person
{
public:
    virtual A* func()
    {
        return new A;
    }
}
class Student:public Person
{
public:
    virtual B* func()
    {
        return new B;
    }
}

多态考题

class A
{
public:
	virtual void func(int val = 1){ std::cout << "A->" << val << std::endl; }
	virtual void test(){ func(); }
};

class B : public A
{
public:
    void func(int val = 0){ std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	B*p = new B;
	p->test();
	return 0;
}

这里输出结果为 B->1

首先p是一个指向B对象的指针，调用test函数由于test没有参数(默认有this指针)，相当于p指针传给this指针，而p是一个B对象的指针，所以调用了B的func()函数，打印了B->

至于val,虚函数重写是接口继承，重写实现。即{ }内的内容是重写的 { }外继承了A中的func()

所以val初始化为了1，打印B->1

class A
{
public:
	virtual void func(int val){ std::cout << "A->" << val << std::endl; }
	void test(){ func(1); }
};

class B : public A
{
public:
	void func(int val){ std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	A*p = new B;

	p->test();
	return 0;
}

这里输入依旧为B->1 因为p是指向B对象的指针，A*仅是改变了该指针的访问形式。对象是谁，就去调用谁的虚函数。

求输出结果

using namespace std;
class A{
public:
 A(char *s) { cout<<s<<endl; }
 ~A(){}
};
class B:virtual public A
{
public:
 B(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
};
class C:virtual public A
{
public:
 C(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
};
class D:public B,public C
{
public:
 D(char *s1,char *s2,char *s3,char *s4)
        :B(s1,s2)
        ,C(s1,s3)
        ,A(s1)
    { 
        cout<<s4<<endl;
    }
};
int main() {
 D *p=new D("class A","class B","class C","class D");
 delete p;
 return 0;
}

按照声明顺序去调用。A虽然没有显示的被继承，但按理来说A是最先被继承的。A的初始化里面B有，C也有，但在D中A是独一份的，所以应该由D来调用A的初始化以避免二义。A初始化之后，按照继承顺序先构造B，再构造C，此时的两者中的A就不会在初始化了。

答案是 class A class B class C class D