C++每日一问：什么是面向对象？面向对象的三大特性

一、什么是面向过程？

面向过程是一种以过程为中心的编程思想，其原理就是将问题分解成一个一个详细的步骤，然后通过函数实现每一个步骤，并依次调用。
面向过程我们所关心的是解决一个问题的步骤，举个例子，汽车发动、汽车熄火，这是两个不同的事件，对于面向过程而言，我们关心的是事件本身，因此我们会使用两个函数完成以上两个动作，然后依次调用即可。

二、什么是面向对象？

面向对象则是一种以对象为中心的编程思想，就是通过分析问题，分解出一个一个的对象，然后通过不同对象之间的调用来组合解决问题。建立对象的目的不是为了完成某个步骤，而是为了描述某个事物在解决整个问题的过程中的行为。
如上面的例子，汽车发动、汽车熄火，对于面向对象而言，我们则关心的是汽车这类对象，两个事件只是这类对象所具备的行为。

三、面向对象的三大基本特征是什么？

• 封装，隐藏内部实现
• 继承，复用现有代码
• 多态，改写对象行为

1、封装

封装就是将一个类的某些信息隐藏在类的内部，不允许外界直接访问，而是提供某些方法实现对隐藏信息的访问和操作。
封装的好处就是增强了数据安全性以及隐藏了类的实现细节，使用者无需了解具体实现细节，只需通过特定的接口进行访问，这样也方便类自身的实现和修改。

2、继承

继承是类与类之间的一种关系，即子类继承父类的特征和行为，使得子类具有和父类相同的属性和行为。
继承的好处在于子类继承了父类的属性和方法从而实现了代码的复用。

3、多态

多态是指一个类对象的相同方法在不同情形下有不同的表现形式。
多态使得具有不同内部结构的对象可以共享相同的外部接口。

多态：父类声明指向子类对象，即引用变量在程序编写的时候不确定，在程序运行的时候才能确定。

实现：子类继承父类并且覆写父类中的方法，或者说实现接口

4、C++重载重写和多态区别

4.1 重载和重写的区别

重载overload：在同一个类中，函数名相同，参数列表不同，编译器会根据这些函数的不同参数列表，将同名的函数名称做修饰，从而生成一些不同名称的预处理函数，未体现多态。

重写override：也叫覆盖，子类重新定义父类中有相同名称相同参数的虚函数，主要是在继承关系中出现的，被重写的函数必须是virtual的，重写函数的访问修饰符可以不同，尽管virtual是private的，子类中重写函数改为public,protected也可以，体现了多态。

重定义redefining：也叫隐藏，子类重新定义父类中有相同名称的非虚函数，参数列表可以相同可以不同，会覆盖其父类的方法，未体现多态。

1）a如果派生类的函数和基类的函数同名，但是参数不同，此时，不管有无virtual，基类的函数被隐藏。
2）b如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有vitual关键字，此时，基类的函数被隐藏。（如果有virtual就成重写了）

#include <iostream>  
using namespace std;  
class Base  
{  
private:  
    virtual void display() { cout<<"Base display()"<<endl; }  
    void show(){ cout<<"Base show()"<<endl; }  
public:  
    void exec(){ display(); show(); }  
    void fun(string s) { cout<<"Base fun(string)"<<endl; }  
    void fun(int a) { cout<<"Base fun(int)"<<endl; }//overload:两个fun函数在Base类的内部被重载  
    virtual int function(){}  
};  
class ClassA:public Base  
{  
public:  
    void display() { cout<<"ClassA display()"<<endl; }//override:基类中display为虚函数，且参数列表一直，故此处为重写  
    void fun(int a,int b) { cout<<"ClassA fun(int,int)"<<endl; }//redefining:fun函数在Base类中不为虚函数，故此处为重定义  
    void show() { cout<<"ClassA show()"<<endl; }//redefining:理由同上  
    int function(int a){}//overload:注意这是重载而不是重写，因为参数列表不同，在编译时ClassA中其实还有个编译器自己偷偷加上的从Base继承来的int function(){};  
};  
int main(){  
    ClassA a;  
    Base *base=&a;  
    base->exec();//display()是ClassA的，因为覆盖了，show()是Base自己的  
    a.exec();//结果同上  
    a.show();//show()是ClassA重定义的  
    base->fun(1);//fun()是Base自己的，因为直接从对象base调用  
    a.fun(1, 1);//fun()是ClassA重定义的  
    return 0;  
}  

4.2 多态性

“一个接口，多种方法”，程序在运行时才决定调用的函数，C++的多态性是通过虚函数来实现的。最常见的用法就是声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话，即没有利用C++多态性，则利用基类指针调用相应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数。因为没有多态性，函数调用的地址将是一定的，而固定的地址将始终调用到同一个函数，这就无法实现一个接口，多种方法的目的了。

a编译时多态性：通过重载函数实现 。
b运行时多态性：通过虚函数实现。

class Parent
{
    virtual void play()
    {
        cout << "play" << endl;
    }
};

class Son : Parent
{
    void play()
    {
        cout << "play phone" << endl;
    }
};

int main() {
    Parent p;
    p.play();
    Son s;
    s.play();                 //父类和子类对象分别调用自己的play()方法，没有异议
    
    Parent p1 = s;
    p1.play();                //此处是对象的拷贝，依旧是父类对象调用父类的play()方法
    
    Parent* p2 = &s;          //父类指针指向子类的对象，与平时的指针定义并不相同。类型* p = &类型（相同类型）
    p2->play();               //此时就产生了多态，申明的父类指针却能够调用子类的play()方法
    
    Parent &p3 = s;           //此时就产生了多态，利用父类的引用指向子类对象。
    p3.play();

    Parent *p4 = new Son();   //利用new返回的是对象的地址，所以需要申明为指针类型
    p4->play();				  //此时就产生了多态，利用父类的引用指向子类对象。
    return 0;
}