在显示生活中肯定形形色色的遇见过不少的人、机构、活动,比如每个人从出生被安排
上了名字、性别、年龄、身份证号等等,为了数据管理方便将其抽象进代码中并不难,在
C语言中使用struct就可以轻松完成，并且结构体比类要简单一些,为什么还有类的诞生呢？
可以这么说,一个人不光有名字等属性，他还会有一些行为,比如说话口音不同,走路姿势不同
等等，这些行为抽象出来的话应该是函数,将struct于函数绑定起来难不难？可想而知,只有开
发者自己知道，而类的作用呢,就是将函数与属性结合起来,一块管理,此时的函数不在称为函数
而是有了更高端的名字------方法或成员函数。由此类诞生了。

# include<iostream>
using namespace std;
class man
{
private:
  char name[10];
  int age;
public:
  man(char* name){
    strcpy(this->name,name)
    age=0;
    cout<<"我出生了";
  }
  void speak(){
    cout<<"大家好,我叫"<<this->name;
  }
  ~man(){
    cout<<"再见！";
  }
};
int main(){
  man* xiaoming = new man("小明");
  //man xiaoming("小明");
  xiaoming->speak();
  delete xiaoming;
  return 0;
}

从第三行到main函数前面一行是类的定义,类中有属性,有方法。
在main函数中的操作是new一个对象,然后调用对象的speak方法,最后
将相应的对象delete掉。

函数名与类名相同,有参无返。【参数个数与类型不固定】
作用是初始化类的属性，在new 对象的时候自动执行。

man(char* name){
  strcpy(this.name,name)
  age=0;
  cout<<"我出生了";
}

~man(){
  cout<<"再见！";
}

定义一个对象变量,并初始化
  man xiaoming("小明");
动态内存申请初始化对象
  man* xiaoming = new man("小明");
  先定义一个该类型的指针
  然后使用new 进行动态内存申请,与malloc类似
  最后让指针指向开辟的内存。

指针调用方法或属性使用->
  xiaoming->speak();
普通变量调用方法或属性使用 .
  xiaoming.speak();

delete 与new相对应
malloc与free相对应
不可以混用。
销毁对象仅仅是解除指针与开辟空间的绑定关系
并不会让指针消失,或者内存中的数据消失,指针依旧可以使用
内存中的数据如果没有被覆盖还会存在

一个类的对象可以作为另一个类的成员属性：
包含后构造包含类时要将被包含类也进行初始化：
初始化列表这么写:(组合类构造函数:被组合对象1初始化，被组合对象2初始化)

例如:用A类的对象作为B类的成员属性;会先初始化A的对象；
如果组合了有多个对象;初始化顺序与对象的定义顺序有关,与对象的初始化列表无关；
组合类对象的构造函数总是最后调用,最先释放(后调用的先释放);
如:在类B中包含了一个类A的对象；

class B {
private:
  int x;
  int y;
public:A a1;//其他类的对象可以做该类的数据成员
  B(int x=0,int y=0):a1(x,y) {
  //嵌套后可以在B的构造函数初始化列表进行A类对象的初始化
    this->x = x;
    this->y = y;
  }
  int getx() {
    return x;
  }
  int gety() {
    return y;
  }
  void print() {
    cout << x <<" "<< y << endl;
    cout << a1.geta()<<" "<< a1.getb() << endl;
    //可以在B类中进行A类对象的初始化与输出
  }
};

class A {
public:
  class AA {
  private:
    int a;
    int b;
  public:
    void print();
  };
private:
  int a;
  int b;
public:
  A(int a, int b) {
    this->a = a;
    this->b = b;
  }
  int geta() {
    return a;
  }
  int getb() {
    return b;
  }
  void print() {
    cout << a << b << endl;
  }
};
void A::AA::print(){//嵌套类
      cout << "this is big OK" << endl;
    }

 static关键字定义的变量放在全局区;并且将初始化的变量与未初始化的变量分开存放
 static变量与全局常量均放在常量区并且二者没有什么本质区别;
 static变量作用域在一个源文件中,全局常量的作用域在一个源程序;
 二者互补缺点,协同作用;
 还有就是static变量的定义在源文件的任何地方都可以,全局变量的定义只在函数体外;
 static不初始化默认值为0,全局变量不初始化默认值为内存中的垃圾值;

定义:  数据类型 类名::变量名=初始化数值;    (在类体外显示的定义)；
    定义后即对静态变量进行初始化；类中的静态数据成员必须要在类外显示的说明
    (目的是让编译器分配内存空间,不然在编译时不报错,使用时会报错)
声明:  static 数据类型 变量名;   (在类体内声明)；

定义:   数据类型 类名::函数名(参数列表)
 {
    定义时可以对类中的静态成员直接使用,不能直接使用非静
    态成员,使用非静态成员要将对应的对象传进来；
   }
声明：static 数据类型 函数名(参数列表);