C++三大特性

面向对象程序设计（OOP）是一种编程范式，它使用“对象”来设计软件。在OOP中，对象是类的实例，类包含数据（属性）和可以对数据执行操作的方法（行为）。

面向对象的核心概念包括封装、继承和多态(C++三大特性)。

什么是类？

在C++中，类是一种用户定义的数据类型，它可以包含数据成员和函数成员。数据成员用于存储与类相关的状态，而函数成员可以定义对这些数据进行操作的方法。可以把类想象为一个蓝图，根据这个蓝图可以创建对象，这些对象在内存中是类的实例。

比如说，我们可以定义一个Car类来表示汽车。这个类可以有数据成员如brand、color和maxSpeed来存储汽车的品牌、颜色和最高速度等属性。同时，Car类可能有函数成员如accelerate()和brake()来定义汽车加速和刹车的操作。

在现实生活中，每辆汽车都是根据汽车制造商设计的蓝图制造出来的，蓝图定义了汽车的特性和功能，类似地，在编程中，我们根据类创建对象来表示现实世界中的各种事物和概念。

class A
{
private:
    int a;
public:
    void print()
    {
        cout << "a=" << a << endl;
    }
    A(int a)
    {
        this->a = a;
    }
};

封装

封装(encapsulation)：是指将数据（属性）和操作数据的代码（方法）打包在一起，形成一个独立的对象。这样可以隐藏对象的内部细节，只暴露必要的操作接口。比如，一个汽车对象封装了引擎、变速器等细节，只提供加速和刹车等接口。

封装实际就是为类中的函数和变量设置访问权限。访问权限包括public,private,protect。其中类对象的默认访问控制权限为private。

（1）public（共有），所有类均可访问

（2）protected（保护），可以被自身和子类访问

（3）private（私有），只能自身和友元函数访问

说明：

（1）public成员可以在类外直接访问。

（2）protected和private成员在类外（在此将这两种限定符都可以看成是私有的，在继承出区别）不能够访问。

（3）它们的作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。

（4）class的默认访问权限是private，而struct为public型(因为struct要兼容C)。C++常用的是class

（5）类外：即脱离了类的作用域或者说访问时不在类的成员函数中。

继承

继承：继承是面向对象软件技术当中的一个概念。如果一个类B继承自另一个类A，就把这个B称为A的子类，而把A称为B的父类。**继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码。在令子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。

子类继承基类后，可以创建子类对象来调用基类函数，变量等。继承包括以下形式：

（1）单一继承：继承一个父类，这种继承称为单一继承，一般情况尽量使用单一继承，使用多重继承容易造成混乱易出问题

（2）多重继承：继承多个父类，通过逗号进行分隔可以让派生类指定多个基类。例如 狗:public 哺乳动物,public 犬科动物

（3）菱形继承：多重继承掺杂隔代继承1-n-1模式，此时需要用到虚继承，例如 B，C虚拟继承于A，D再多重继承B，C，否则会出错

继承的代码表示为：

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

继承方式规定了如何访问继承的基类的成员。继承方式指定了派生类成员以及类外对象对于从基类继承来的成员的访问权限

继承权限：子类继承基类除构造和析构函数、基类的重载运算符、基类的友元函数以外的所有成员，继承可以扩展已存在的代码，目的也是为了代码重用。

另外，继承可分为接口继承和实现继承：

（1）普通成员函数的接口总是会被继承：　　子类继承一份接口和一份强制实现

（2）普通虚函数被子类重写　　　　　：　　子类继承一份接口和一份缺省实现

（3）纯虚函数只能被子类继承接口　　：　　子类继承一份接口，没有继承实现

访问权限图如下：

友元函数是C++中的一个概念，它允许某些非成员函数访问类的私有成员和保护成员，这通常是为了提高程序的运行效率。友元函数虽然在语法上看起来像普通的函数，但在定义时需要在类体内使用关键字friend进行说明，以表明它不是该类的成员函数，但可以访问类的私有和保护成员。(1)(2)

友元函数的特点和注意事项如下：

• 特点。友元函数可以访问类中的私有和保护成员，这使得它在某些情况下比类的成员函数更灵活。然而，这也意味着它可能会破坏类的封装性，因为非成员函数现在可以直接访问类的私有部分。

• 注意事项。友元函数在类中的声明位置（如private、protected、public区域）并不影响其访问权限，友元函数可以在任何位置定义，并且不需要是类的成员函数。友元函数也不能被继承，即父类的友元函数不会自动成为子类的友元函数。

另外，友元关系不具有对称性和传递性，这意味着如果A是B的友元，那么B不一定是A的友元，且A和B的友元关系不会传递到其他类。总的来说，友元函数是一种在特定情况下提高程序效率的工具，但使用时需要权衡其对封装性的影响。

" 友元函数 " 中 , 需要有一个参数是 类对象的 指针 ;

问题1：下面的代码会输出什么？

void main()
{
    A a1(1);
    B b1(2,3);
    a1.print();//输出啥？1
    b1.print(); //输出啥？3
    system("pause");
}

void main()
{
    A a1(1);
    B b1(2,3);
    A *base1 = NULL;
    base1 = &a1;
    base1->print();  //父类  1
    A *base2 = NULL;
    base2 = &b1;
    base2->print();   //父类  2
    A &base3 = a1;
    base3.print();   //父类  1
    A &base4 = b1;
    base4.print();   // 父类  2

    system("pause");
}

多态

但是这不是我想要的，我希望的是，可以输出对应类的print()

希望编译器根据实际的对象类型来判断重写函数的调用

如果父类指针指向的是父类对象则调用父类中定义的函数

如果父类指针指向的是子类对象则调用子类中定义的函数

因此就出现了面向对象的多态概念。

多态（Polymorphisn）：不同类的对象可以通过同一接口调用，具有不同的行为。例如，如果有一个函数接受车辆类的对象，那么任何车辆的子类对象，如汽车或摩托车，都可以使用该函数，但具体的行为会根据对象的实际类型而有所不同。多态性在C++中都是通过虚函数（Virtual Function）实现的。虚函数就是允许被其子类重新定义的成员函数，用virtual修饰。而子类重新定义父类虚函数的做法，称为“覆盖”或者称为“重写”（override）。

ps:虚函数是在函数前加了virtual的函数；纯虚函数是前面加了virtual，同时函数被=0的函数，纯虚函数不能被调用

C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。简单地说，多态意味着单个函数可以有多个不同的实现。

解决方案：在同名的成员前，加上virtual。

• C++中通过virtual关键字对多态进行支持

• 使用virtual声明的函数被重写后即可展现多态特性

改写上面的例子：

#include <iostream>
using namespace std;
class A
{
private:
    int a;
public:
    virtual void print()
    {
        cout << "a=" << a << endl;
    }
    A(int a)
    {
        this->a = a;
    }
};
class B : public A
{
private:
    int b;
public:
    virtual void print()
    {
        cout << "b=" << b << endl;
    }
    B(int a, int b) : A(a)
    {
        this->b = b;
    }
};

void main()
{
    A a1(1);
    B b1(2,3);    
    A *base1 = NULL;
    base1 = &a1;
    base1->print();   //1
    A *base2 = NULL;
    base2 = &b1;
    base2->print();   //3
    A &base3 = a1;
    base3.print();  //1
    A &base4 = b1;
    base4.print();  //  3

    system("pause");
}

多态是基于虚函数来实现的。多态实现的三大条件：

（1）要有继承

（2）要有虚函数重写（被调用的函数必须是虚函数，且完成了虚函数的重写）

（3）父类指针或引用指向子类对象

#include <iostream>
class Person 
{
public:
    virtual void BuyTicket(int)
    {        std::cout << "Adult need Full Fare!" << std::endl;
    }   
};

class Child : public Person
{
public:
    virtual void BuyTicket(int)
    {        std::cout << "Child Free!" << std::endl;
    }   
};

void fun(Person& obj)
{
    obj.BuyTicket(1);                                                                                                                             
}

int main(void)
{
    Person p;
    Child c;

    fun(p);
    fun(c);
    return 0;
}