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修饰的函数，在类的继承中采用动态继承的方式。

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

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” 告诉编译器，函数没有主体。

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

采用纯虚函数的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) = 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）虚继承

在多继承情况下，虚拟继承可也解决菱形继承中出现的多测实例化基类和多次调用基类析构函数的问题。

在虚继承的方式下，基类只被实例一次，也只被析构一次。

虚继承方法：只需要在继承定义中使用virtual修饰子类就可以了

虚基类：在继承中被virtual修饰的子类叫做虚基类

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) {}
};

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

int main(int argc, char **argv)
{
    Derived der;
    Base derB;

    der.add(1.1, 2.2);
    derB.add(1.1, 2.2);
    return 0;
}