C++基础（一）：C++的特性

C++是一个面向对象的语言，而C偏向于过程
所以C++拥有了面向对象的三大特性：封装 继承 多态
封装：隐藏类的属性和实现细节，仅仅对外提供接口

• 封装性实际上是由编译器去识别关键字public private protected来实现的，体现在类的成员可以有公有成员、私有成员和保护成员。私有成员是封装体内被隐藏的部分，只有类体内说明的函数（类的成员函数）才可以访问私有成员，而在类体外的函数是不能访问的；公有成员是封装体对外界的一个借口，类体外的函数可以访问公有成员；保护成员是只有该类的成员函数和该类的派生类才可以访问的
• 优点：隔离变化；便于使用；提高重用性；提高安全性
• 缺点：如果封装太多，影响效率；使用者不能知道代码的具体实现

继承：被继承的是父类，继承出来的是子类。子类拥有父类的所有特性。继承方式有公有继承、私有继承、保护继承，默认是私有继承

• 公有继承中父类的公有和保护成员在子类中不变，私有成员在子类中不可访问
• 私有继承中父类的保护和公有成员在子类中变为私有，但私有成员在子类中不可访问
• 保护继承中父类的公有和保护成员在子类中变为保护，但私有成员在子类中不可访问
• C++允许单继承和多继承
• 继承优点：减少了重复的代码，继承是多态的前提，继承增加了类的耦合性
• 继承缺点：在编译时刻就定义了，无法在运行时刻改变父类继承的实现；父类通常至少定义了子类的部分行文，父类的改变都可能影响子类的行为；如果继承下来的子类不适合解决新问题，父类必须重写或替换，那么这种依赖关系就限制了灵活性，最终限制了复用性

多态：是指对不同类的对象发出相同的消息将会有不同的实现

• C++有两种多态，一种是动态多态（运行期多态），一种是静态多态（编译器多态）。静态多态主要是通过重载来实现的，而动态多态是通过虚函数来实现的，即在基类中存在虚函数（一般为纯虚函数），子类通过重载这些接口，使用基类的指针或者引用指向子类的对象，就可以调用子类对应的函数，动态多态的函数调用机制是编译期才能确定的，所以是动态
• 多态优点：大大提高了代码的可复用性；提高了代码的可维护性，可扩充性
• 多态缺点：易读性比较不好，调试比较困难；模板只能定义在头文件中，工程大了之后编译时间很长

class Person{
protected:
    int high;
    int age;
    int weight;
public:
    Person(int high,int age,int weight){    //用了重写来实现静态多态
        Person::high=high;
        Person::age=age;
        Person::weight=weight;
    }
    Person(){
        Person::high=0;
        Person::age=0;
        Person::weight=0;
    }
    void print2(){
        cout<<"this is a person"<<endl;
    }
    virtual void print(){       //虚函数来实现动态多态
        cout<<"person info:high="<<Person::high<<",weight="<<Person::weight<<",age="<<Person::age<<endl;
    }
};

class Student: public Person{
public:
    Student(int high,int weight,int age,int grade){
        this->high=high;
        this->weight=weight;
        this->age=age;
        this->grade=grade;
    }
    void print2(){
        cout<<"this is a student"<<endl;
    }
    void print() override{	// override表示重写虚函数
        cout<<"student info:high="<<Student::high<<",weight="<<Student::weight<<",age="<<Student::age;
        cout<<",grade="<<Student::grade<<endl;
    }
private:
    int grade;
};

int main(){
    Person P1(180,30,99);
    Person P2;
    P1.print();
    P2.print();	//这两个是静态多态
    Person* S=new Student(170,80,20,80);
    S->print();	//这两个是动态多态
    S->print2();
    //测试了一下，好像如果是protected/private继承的话，是不能够new的，只能定义（也不知道对不对
    return 0;
}

output：
person info:high=180,weight=99,age=30
person info:high=0,weight=0,age=0
student info:high=170,weight=80,age=20,grade=80
this is a person

class A{
public:
    int a;
};
class B{
public:
    int b;
};
class C: public A, public B{
public:
    int c;
    C(int a,int b,int c){
        this->a=a;
        this->b=b;
        this->c=c;
    }
    void print () const{
        cout<<"a="<<this->a<<" b="<<this->b<<" c="<<this->c<<endl;
    }
};

int main(){
    C c(1,2,3);
    c.print();
    return 0;
}

output:
a=1 b=2 c=3

面试中可能会问到的问题是：

1. C++的特性？
2. 多态有哪几种？（然后就会开始问虚函数了）
3. 继承以及多重继承？多重继承的二义性，为什么会有二义性，如何避免？