C++——虚函数，纯虚函数，函数重载

异质链表

虚函数
虚函数主要用于多态

若一个类中含有虚函数
则系统会自动的创建一个表，
该表用于存放虚函数的入口地址
称该表为虚函数表

该类会自动添加一个指针，
该指针存放虚函数表的首地址
称该指针为虚函数表指针

纯虚函数
实现多态，实现没有意义-->定义为纯虚函数
含有纯虚函数的类称之为抽象类
抽象类不能定义对象

若派生类中，没有对纯虚函数进行定义
则该派生类仍为抽象类，不能定义对象

如果想用派生类生成对象，
则在派生类中必须要对纯虚函数进行定义

若派生类中存在和基类虚函数函数原型相同的函数
则该派生类函数默认为虚函数

系统会自动的用该派生类函数的地址
覆盖掉虚函数表中和其函数原型相同的基类的虚函数的地址

指针能够访问的范围受类型局限
即只能访问该指针类型中的成员
通过基类的指针或者引用来调用函数时
若该函数为虚函数，则到虚函数表中查找其入口地址
获得地址后，转到该地址执行函数

若派生类中存在和基类同名的成员变量
优先使用派生类中的成员变量

静态联边和动态联边

静态联边的对象是在编译后确定（多态）
动态联边的对象是在运行时确定

在类中定义的普通函数默认为inline函数
（静态成员函数，虚函数，构造函数，析构函数，不能为inline函数）
inline定义的内联函数，函数代码被放入符号表中，
在使用时进行替换（像宏一样展开），效率很高。
类的内联函数也是函数。编绎器在调用一个内联函数，
首先会检查参数问题，保证调用正确，
像对待真正函数一样，消除了隐患及局限性。
inline可以作为类的成员函数，又可以使用所在类的保护成员及私有成员

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

class Shape
{
public:
    //虚函数
    //虚函数主要用于多态

    //若一个类中含有虚函数
    //则系统会自动的创建一个表，
    //该表用于存放虚函数的入口地址
    //称该表为虚函数表

    //该类会自动添加一个指针，
    //该指针存放虚函数表的首地址
    //称该指针为虚函数表指针
    virtual float getArea()
    //float getArea()
    {
        return 0;
    }
};

class Rectangle: public Shape
{
public:
    Rectangle(float w = 0, float h = 0)
    {
        m_fWidth = w;
        m_fHeight = h;
    }
    //若派生类中存在和基类虚函数函数原型相同的函数
    //则该派生类函数默认为虚函数
    
    //系统会自动的用该派生类函数的地址
    //覆盖掉虚函数表中和其函数原型相同的基类的虚函数的地址
    float getArea()
    {
        return m_fWidth * m_fHeight;
    }
    //类中定义的普通函数默认为inline函数
    //静态成员函数，虚函数，构造函数，析构函数不能为inline
    //inline void test() 
    void test() 
    {}
private:
    float m_fWidth;
    float m_fHeight;
};

class Triangle: public Shape
{
public:
    Triangle(float b = 0, float h = 0)
    {
        m_fBottom = b;
        m_fHeight = h;
    }
    float getArea()
    {
        return m_fBottom * m_fHeight / 2;
    }
private:
    float m_fBottom;
    float m_fHeight;
};
#if 1
//指针能够访问的范围受类型局限
//即只能访问该指针类型中的成员
void fun(Shape *pShape)
{
    //通过基类的指针或者引用来调用函数时
    //若该函数为虚函数，则到虚函数表中查找其入口地址
    //获得地址后，转到该地址执行函数
    cout << pShape->getArea() << endl;
//  pShape->test();  //error
}
#endif

int main(void)
{
    cout << sizeof(Shape) << endl;
    Rectangle rec(3,4);
//  cout << rec.getArea() << endl;
    fun(&rec);  
    Triangle tri(3,4);
//  cout << tri.getArea() << endl;
    fun(&tri);
    Shape sh;
//  cout << sh.getArea() << endl;
    fun(&sh);
    return 0;
}

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

class Shape
{
public:
    //纯虚函数
    //实现多态，实现没有意义--》定义为纯虚函数
    //含有纯虚函数的类称之为抽象类
    //抽象类不能定义对象

    //若派生类中，没有对纯虚函数进行定义
    //则该派生类仍然为抽象类，不能定义对象

    //如果想用派生类生成对象，
    //则在派生类中必须对纯虚函数进行定义
    virtual float getArea() = 0;
};

class Rectangle: public Shape
{
public:
    Rectangle(float w = 0, float h = 0)
    {
        m_fWidth = w;
        m_fHeight = h;
    }
    float getArea()
    {
        return m_fWidth * m_fHeight;
    }
private:
    float m_fWidth;
    float m_fHeight;
};

class Triangle: public Shape
{
public:
    Triangle(float b = 0, float h = 0)
    {
        m_fBottom = b;
        m_fHeight = h;
    }
    float getArea()
    {
        return m_fBottom * m_fHeight / 2;
    }
private:
    float m_fBottom;
    float m_fHeight;
};
void fun(Shape *pShape)
{
    cout << pShape->getArea() << endl;
}

int main(void)
{
    Rectangle rec(3,4);
    fun(&rec);  
    
    Triangle tri(3,4);
    fun(&tri);
    
    return 0;
}

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

class Complex
{
public:
    Complex(int real = 0, int vir = 0)
    {
        m_iReal = real;
        m_iVir = vir;
    }
    void show()
    {
        cout << m_iReal << '+' << m_iVir << 'i' << endl;
    }
    friend Complex operator+(const Complex &c1
                             , const Complex &c2);
    friend Complex operator-(const Complex &c1
                             , const Complex &c2);
    friend bool operator>(const Complex &c1
                          , const Complex &c2);
private:
    int m_iReal;
    int m_iVir;
};

//返回值类型：Complex
//函数名：operator+
//形参列表：const Complex &c1, const Complex &c2
Complex operator+(const Complex &c1, const Complex &c2)
{
    Complex com;
    com.m_iReal = c1.m_iReal + c2.m_iReal;
    com.m_iVir = c1.m_iVir + c2.m_iVir;
    return com;
}
Complex operator-(const Complex &c1, const Complex &c2)
{
    Complex com;
    com.m_iReal = c1.m_iReal - c2.m_iReal;
    com.m_iVir = c1.m_iVir - c2.m_iVir;
    return com;
}

bool operator>(const Complex &c1, const Complex &c2)
{
    if (c1.m_iReal > c2.m_iReal 
        || ((c1.m_iReal == c2.m_iReal)
             &&(c1.m_iVir > c2.m_iVir)))
    {
        return true;
    }
    return false;
}

int main(void)
{
    Complex com(3, 4);
    com.show();

    Complex com2(4, 9);
    com2.show();

    //Complex com3 = com + com2;
    Complex com3 = operator+(com, com2);
    com3.show();
    
    //Complex com4 = com - com2;
    Complex com4 = operator-(com, com2);
    com4.show();

    if (com3 > com4)
    {
        cout << "com3 > com4" << endl;
    }
    else
    {
        cout << "com3 <= com4" << endl;
    }

    return 0;
}