c+++++必须懂的原理，底层逻辑

const Rect& compair(const Rect& r1, const Rect& r2)
{
    return r1.getArea() > r2.getArea() ? r1 : r2;
}
int main()
{
    Rect r1;
   
    Rect* r2 = new Rect();

compair(r1,*r2)
//发生的是const Rect& r1=r1  
const Rect& r2=*r2；因为平常的就是r1就是一个值，所以后面的也要一个值就是*r2

C中动态开辟空间的方式：
 int* p = (int*)malloc(sizeof (int));
无初始化开辟空间；
 int* p1 = (int*)calloc(1,sizeof (int));
初始化为0，开辟空间
  int* p2 = (int*)realloc(p1,sizeof (int)*5);
在已经开辟的空间重新开辟空间，也就是说p2保存的值跟p1是一样的

C++动态开辟空间的方式：
new（他的底层实现就是malloc）
   1. int* p = new int;//无初始化
    cout << *p << endl;//这个应该为随机值
   1.1 int* p1 = new int(100);初始化值为100
    cout << *p1 << endl;这个值为100
2  int* p2 = new int[1024];连续开辟1024个空间无初始化
int* p3 = new int[1024]{1,2,3};连续开辟1024个空间，前三个初始化为1 2 3
    for(int i = 0; i < 1024; i++)
    {
        cout << p3[i] << " ";
    }

释放堆上空间：如果是连续开辟空间就是delect【】p2；如果是单独开辟就是delect p1

对于内置类型（像float，int，类型的开辟如int*p=new int（），int*p=new int【1024】）
在使用释放十可以使用delect或者delect【】；因为他们的底层实现都是malloc

而对于自定义类在连续开辟多个空间时候（像STU *pstu=new STU【11】），在delect起始地址的上边
还有一个int（4个字节）来保存要开辟几个空间，所以连续开辟多个空间，释放时候必须用delect【】；

对象的组成 属性方法；特点：封装继承多态唯一
类：具有同一种属性与行为的对象可以抽象成为一个类
总结：类即为一些具有共有属性与行为的抽象。对象就是类的实例。

类的封装性 = 访问权限 + 属性 + 行为。
class + 类名
{
    //访问权限:public,private,protected
    //对象的抽象出来的共有属性。
    //对象抽象出来的共有的行为（方法）。
};
public :是公有的，类内类外对象均可访问。
private:是私有的，只有是本类类内访问，类外不可访问。（也就是在类内进行this）
protected：是受保护的，只有在本类类内及继承子类的类内进行访问，类外不可访问。

如果类外对象想要访问类内中的私有的或者受保护的属性或方法，在piblic手动调用set（），get（）

类中的构造函数：（就是给类对象中属性进行初始化的）
当类中没有构造函数是，编译器会生成一个无参的新构造；
如果这个类对象开辟空间是在栈上，那么生成的构造函数的功能就是随机给类对象赋初始值；
如果这个类对象开辟空间实在堆上，那么编译器就会优化，这个构造函数给类对象赋的初始值就是0；
如果已经有了类中有了构造，那么就不会在主动生成构造函数了
构造函数特点：
1构造函数名和类名一样，后面小括号里是形参列表，是用来接受外面的值的；
(是在创建类对象的时候给构造函数传递参数的)

自定义类对象：在栈上 Stu a；Stu a（12，19），（）小扩号里面的是给构造函数传参（用来初始化）
在堆上：Stu *pa=new Stu；类对象的值为随机值，
Stu*pa=new Stu（），这样的是类对象的值为0
Stu*pa=new Stu（12，19）小括号也是用来给构造函数传参（来初始化）

类中构造函数的调用时机，在栈上定义类对象的时候，就会自动调用类中的构造函数；
在堆上 ，new开辟空间之后自动调用与之参数类型匹配的构造函数！！！！！！！！！！！！！

构造函数调用也分成隐式调用和显式调用
Stu a（12，19）显
Stu a={12，19}隐
Stu a=35；因
 A a1(10);隐（隐式调用也会自动匹配构造函数类型）

析构函数的调用时机及意义：
当类对象被销毁时，编译器会自动调用类中的构造函数完成类中属性指针指向堆上资源的清理（释放）
这样可以避免，内存的泄漏。

const Stu& compair(const Stu& stu1, const Stu& stu2)
{    
 return stu1.getAge() > stu2.getAge() ? stu1 : stu2;}

如果不加&  const Stu stu1=stu；会调用一次析构；这个函数会调用三次析构，也就是传参和返回时都会调用析构；

（是对类中的指针指向的资源的清理）

关于const
1首先在c++语法中规定，const修饰的变量，必须在定义的时候完成初始化

构造函数的特殊语法：初始化列表：
：初始化列表：（初始化列表是早与构造函数形成的，是开辟空间的同时形成的）（初始化列表能提高构造函数效率）
private:
    string _name;
    int _age;
    int* _p;
    const int _id = 1003;（因为const修饰的变量，必须在定义的时候完成初始化）
    A a = A(1);
 Stu(string name, int age, int id):_name(name),_age(age),_p(new int[1024]),_id(id),a(A(1))
    {
        cout << "Stu的有参构造" << endl;（这个_是一个习惯规范）
    }
——————————————————————————————
不使用初始化列表
   Stu(string name, int age)
    {
        this->name = name;
        this->age = age;
        this->p = new int[1024];
        cout << "Stu的有参构造" << endl;
    }

static修饰的静态变量

当用static修饰一个变量时，他的储存形态发生改变，
static int const；在类空间中，只有一个声明没有定义；
计算机不知道里面有什么类型，就不调用到静态区了，只是一个声明而已，所以应该然计算机找到它
故：类中静态属性初始化方式是让计算机找到它，在全局的话应该是int stu：：count=0；（找不到它就不能开辟空间，找到它开辟空间），以便后期调用