C++的静态多态性和动态多态性

在C++中封装和继承只是对类的重用，将类封装起来，而多态性则是对函数接口的重用。
多态性分为：静态多态性，动态多态性.
静态多态性：指的是在程序编译阶段就确定的函数执行过程。多用于函数重载。
动态多态性指的是只有在程序执行过程中才确定的是动态多态性，多用于虚函数。
函数重载：
函数重载中之前接触到的一个例子就是构造函数，一个类中有多个构造函数。创建对象时需要根据参数列表来确认。
class CComplex
{
public：
CComplex();
CComplex(int ,int);
CComplex(char ,char);
......
}
另外的重载则是普通函数的重载，一个类中有多个名字相同，但参数列表不同的成员函数，也是函数重载，节约了函数名。
class CComplex
{


public:
void print();
void print(int ,int);
void print(char ,char);
}
运算符重载：
在C++或者C中运算符并非一个单纯的符号，而是函数的调用，比如+在c++ 中则是为int operator +(int,int)
既然普通函数可以重载，那么运算符对应的函数也是可以重载。C++中的函数重载往往是对对象的运算。在调用时会根据是一般参数还是对象来执行运算符函数。
运算符重载时可以定义为成员函数，也可以定义为友元函数，
成员函数时因为有this存在，所以会形参少一个参数，所以双目运算符最好定义为友元函数，单目运算符定义为成员函数。
在C++中有些运算符不能重载，如：.->类成员运算符,*->类指针运算符，::作用域运算符，?:条件运算符,sizeof求字节运算符。
class CComplex
{
public:
friend CComplex operator+(CComplex &,CComplex&);
private：
int x;
}


CComplex operator+(CComplex &c1,CComplex &c2)
{
CComplex c3;
c3.x=c1.x+c2.x;//或者有显性构造函数直接执行先行构造函数CComplex(c1.x+c2.x);
return c3;
 
}
虚函数：
虚函数实现了动态多态性。程序执行时才确定调用的函数代码。
如果不采用虚函数，则类数据在封装时，函数为公有，数据则是对象私有。
虚函数有很强的继承性，只要基类的某一函数为虚函数，在派生类中，只有返回值参数一样，形参的个数和类型完全一致，则派生类中不用加入virtual也是虚函数。
虚函数的好处就是运行时必须通过对象引用或者对象指针来实现，一般流程是：基类定义一个指针或者引用，指向或者引用派生类时，调用虚函数，则是分别调用派生类的实现。
如果不是虚函数，则调用的是基类的函数实现。但数据还是派生类的数据。
纯虚函数在继承派生过程中一定会被覆盖。
#include
using namespace std;
class A
{
public:
    //void print(){cout<<"A::print"<     virtual void print(){cout<<"A::print"<     A(int);
private:
    int x;
};
A::A(int t)
{
x=t;
}
class B:public A
{
public:
    void print(){cout<<"B::print"<     B(int,int);
private:
    int y;
};
B::B(int x1,int x2):A(x1)
{
    y=x2;
}
int main(void)
{
    B b(3,4);
    A a(3);
    A *p_b;
    p_b=&a;
    p_b->print();
    p_b=&b;
    p_b->print();
    return 0;
}
纯虚函数：
纯虚函数定义方式：后边加入=0；
virtual double area()=0;
一个类如果有纯虚函数，则这个类被称为抽象类。
在继承和派生中，如果纯虚函数没有改写，则派生类依然是纯虚函数。
抽象类不能建立对象，只能是其他类的基类。不能做函数参数的类型，函数返回值。或者其他转换。
可以声明抽象类的指针或者引用。
#include
using namespace std;
class A
{
public:
    //void print(){cout<<"A::print"<     virtual void print()=0;
    A(int);
private:
    int x;
};
A::A(int t)
{
x=t;
}
class B:public A
{
public:
    void print(){cout<<"B::print"<     B(int,int);
private:
    int y;
};
B::B(int x1,int x2):A(x1)
{
    y=x2;
}
int main(void)
{
    B b(3,4);
    //A a(3);
    A *p_b;
    b.print();
    //p_b=&a;
   // p_b->print();
    p_b=&b;
    p_b->print();
    return 0;
}