C++多态

1、静态多态

（1）函数重载

 函数重载以参数的类型或数量不同来区分不同用途的同名函数。

不以返回值不同来区分函数。

编译器在调用函数时会在意函数的参数，不会在意函数的返回值。

int myAdd(int a, int b);
float myAdd(double a, double b);

（2）运算符重载

 使用关键字operator来重载函数的运算符，自定义运算符的功能。

可以用于结构体和类之间的运算。

类的运算符重载：

class Base {
public:
    Base()
    {
        name = "hany";
        age = 100;
        value = 666.666;
    }
    ~Base() {}
    Base operator+(const Base &);
    string name;
    int age;
    double value;
    double add(double a, double b);
};

Base Base::operator+(const Base &ccc)
{
    Base bbb;
    bbb.age = this->age + ccc.age;
    bbb.name = this->name + ccc.name;
    bbb.value = this->value + ccc.value;
    return bbb;
    operator+
}

int main(int argc, char **argv)
{
    Base b1;
    Base b2;
    Base b3 = b1 + b2;
    cout << b3.name << endl;
    cout << b3.age << endl;
    cout << b3.value << endl;
    return 0;
}

结构体的运算符重载 ：

struct person {
    int age;
    double value;
};

struct person operator+(const struct person &a, const struct person &b)
{
    struct person c;
    c.age = a.age + b.age;
    c.value = a.value + b.value;
    return c;
}

int main(int argc, char **argv)
{
    struct person b1;
    struct person b2;
    struct person b3 = b1 + b2;
    cout << b3.age << endl;
    cout << b3.value << endl;
    return 0;
}

2、动态多态

（1）虚函数

 用virtual修饰的函数，在类的继承中采用动态继承的方式。

采用虚函数的base类不能实例对象。

在子类中可以再次定义虚函数相应的功能。

class Base {
public:
    Base()
    {
        name = "hany";
        age = 100;
        value = 666.666;
    }
    ~Base() {}
    string name;
    int age;
    double value;
    virtual double add(double a, double b) { return (a + b); }
};
class Derived : public Base {
public:
    Derived() : Base() {}
    virtual double add(double a, double b)
    {
        double c = a + b;
        cout << c << endl;
        return c;
    }
};

int main(int argc, char **argv)
{
    Derived der;
    der.add(1.1, 2.2);
    return 0;
}

// 类中的成员变量和成员函数默认是private访问权限

（2）纯虚函数

纯虚函数在虚函数后加“ = 0;”

= 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

纯虚函数不能被直接继承调用，只能重写。

class Base {
public:
    Base()
    {
        name = "hany";
        age = 100;
        value = 666.666;
    }
    ~Base() {}
    string name;
    int age;
    double value;
    virtual double add(double a, double b) = 0;
};

class Derived : public Base {
public:
    Derived() : Base() {}
    virtual double add(double a, double b)
    {
        double c = a + b;
        cout << c << endl;
        return c;
    }
};

int main(int argc, char **argv)
{
    Derived der;
    der.add(1.1, 2.2);
    return 0;
}

（3）虚继承