2021-01-12

C++知识点整理

 

1.虚函数重写

#include<iostream>  
using namespace std;  
  
class A  
{  
public:  
    void foo()  //非虚函数
    {  
        printf("1\n");  
    }  
    virtual void fun()  //虚函数
    {  
        printf("2\n");  
    }  
};  
class B : public A  
{  
public:  
    void foo()  
    {  
        printf("3\n");  //非虚函数同名未重写，被隐藏，不可override
    }  
    void fun()  
    {  
        printf("4\n");  //虚函数，被override
    }  
};  
int main(void)  
{  
    A a;  
    B b;  
    A *p = &a;  //p为A类指针指向A对象
    p->foo();  //打印1
    p->fun();  //打印2
    p = &b;    //p为A类指针指向派生类B对象
    p->foo();  //非虚函数，派生类被隐藏，使用基类函数，打印1
    p->fun();  //虚函数被重写，打印4
    return 0;  
} 

第一次传引用，相当于父类指针指向了派生类，调用了派生类版本；第二次传值，是用派生类对象赋值给基类对象，其实仅仅拷贝了派生类的基类部分，因此调用基类版本:

class A {
    public:
        virtual void Func(int a = 2)
        {
            cout << a << endl;
        }

        void foo(int b = 3)
        {
            cout << b << endl;
        }
};
class B : public A{
public:
    void Func(int a = 3)
    {
        cout << a * 100 <<endl;
    }

    void foo(double b = 5)
    {
        cout << b * 10 << endl;
    }

    void test1(A &a)
    {
        a.Func();
    }

    void test2(A a)
    {
        a.Func();
    }
};
int main() {
    A a;
    B b;
    A *p = &b;

    p->Func(); //200
    p->foo();  //3

    p = &a;
    p->Func(); //2
    p->foo();  //3

    B *q = &b;
    q->Func(); //300
    q->foo();  //50
    cout<<"------------------"<<endl;
    B *t = new B();
    q->test1(*t);  //A *a = &b  子类方法，基类赋值， 200

    q->test2(*t);   //(A) *b; 基类赋值，基类函数， 2 派生类强转为基类，只保留基类的东西

}