【C++类和对象（上）】—— 我与C++的不解之缘（三）

前言：

通过了C++入门基础的学习，对C++有了一定的了解，现在来学习C++中的类和对象

一、类的定义

       1.1、类的定义格式

       class 为定义类的关键字，Stack为类的名字，{}中为类的主体（注意类定义结束后的分好不能省略），类体中内容称为类的成员：类中的变量称为类的属性(或者 类的成员变量)；类中的函数称为类的方法(或者 类的成员函数)。

       为了区分成员变量，（习惯上会加上一个特殊标识，前面或者后面加上_或m(这只是惯例，C++ 没有要求)）。

       C++中struct也可以定义类，C++兼容C语言struct的用法，而且把struct 升级成了类（可以定义成员函数），一般还是使用class 来定义类。

       定义在类里面的成员函数默认为 inline。

这样就定义了一个域Data，Init 和 Print 是成员函数；_year、_month 和 _day是成员变量。

class Data
{
public:
  //成员函数
  void Init(int year = 1, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Print()
  {
    cout << _year << "/" << _month << "/" << _day << endl;
  }
private:
  //成员变量
  int _year;
  int _month;
  int _day;
};

       1.2、访问限定符

       C++一种实现封装的方式，用类将对象的属性和方法结合在一起，让对象更加完善，通过访问权限选择性的将接口提供给外部的用户使用

       public 修饰的成员在类外可以直接被访问，protected 和privata修饰的成员在类外不能直接被访问，（在继承中才能体现出protected 和privata的区别）。

       访问权限作用域从该访问限定符出现的位置开始，直到下一个访问限定符出现为止；如果后面没有访问限定符，作用域就到 } 为止。

       class定义成员没有被访问限定符修饰时默认为private，struct默认为public。

       ⼀般成员变量都会被限制为private/protected，需要给别⼈使⽤的成员函数会放为public。

访问权限有以下三种：

以上面定义的域Data为例，privata 修饰的成员是私有的，不能直接被访问。

而public修饰的成员可以被直接访问。

       1.3、类域

       类定义了应该新的域，类的所有成员都在类的作用域中，在类体外定义成员时，需要使用  ::  作用域操作符来指明成员属于那个类域

       类域影响的是编译的查找规则，下面程序如果不指定类域Stack，那编译就把Init当成了全局函数，那么编译时，就找不到array等成员的声明和定义，就会报错；指定类域Stack，就知道Init是成员函数，当前域找不到array等成员，就会到类域中去查找。

这里，类里的成员函数如果声明和定义分离，就需要指定类域，

class Stack
{
public:
  // 成员函数
  void Init(int n = 4);
private:
  // 成员变量
  int* array;
  size_t capacity;
  size_t top;
};
// 声明和定义分离，需要指定类域
void Stack::Init(int n)
{
  array = (int*)malloc(sizeof(int) * n);
  if (nullptr == array)
  {
    perror("malloc申请空间失败");
    return;
  }
  capacity = n;
  top = 0;
}
int main()
{
  Stack st;
  st.Init();
  return 0;
}

二、类的实例化

       2.1、实例化出对象

       用类这一类型在物理内存中创建对象的过程，称为类实例化出对象

       类是对象进行一种抽象描述，是一个模型一样的东西，限定了类有哪些成员，这些成员只是声明，没有分配空间，有用类实例化出对象时，才会分配空间

       一个类可以实例化出多个对象，而实例化出的对象，占用实际的物理空间，存储类成员变量。

       这里类就像C语言实现链表时，创建的链表节点的结构体一样；只是限定了有哪些成员，没有实际开辟空间，只有在使用的时候才开辟空间创建变量。

class Data
{
public:
  //成员函数
  void Init(int year = 1, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Print()
  {
    cout << _year << "/" << _month << "/" << _day << endl;
  }
private:
  //成员变量
    //只声明，没有开辟空间
  int _year;
  int _month;
  int _day;
};
int main()
{
    //Data实例化出对象 d1
  Data d1;
  d1.Init();
  d1.Print();
    //Data实例化出对象 d2
  Data d2;
  d2.Init(2024, 8, 7);
  d2.Print();
 
  return 0;
}

       2.2、对象的大小      

       这里实例化出的每一个对象都有独立的空间，那么这些对象的大小该入额计算呢？

类中存在成员变量：

       这里，大小只计算成员变量的大小，成员函数不计算在内，（计算成员变量的大小与C语言中计算结构体一样都遵循内存对齐规则）

计算一下，上面类Data实例化对象d1的大小：

int main()
{
  Data d1;
  d1.Init();
 
  cout << sizeof(d1) << endl;
  return 0;
}

       大小为12（单位字节）

类中不存在成员变量：

       这里可能有点疑惑，上面不是说只计算成员变量的大小吗？那不存在成员变量，大小又是多少呢？

       如果不存在成员变量，那对象的大小为1，（这里为什么没有成员变量，还要给一个字节空间呢？）这里如果空间大小为0，那怎么表示这个对象是否存在呢?（这里的一个字节，纯粹是占位标识对象存在）。

class H
{
public:
 
};
 
int main()
{
  H h;
  cout << sizeof(h) << endl;
  return 0;
}

三、this指针

       Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调⽤Init和 Print函数时，该函数是如何知道应该访问的是d1对象还是d2对象呢？那么这⾥就要看到C++给了 ⼀个隐含的this指针解决这⾥的问题

       编译器编译后，类的成员函数默认都会在形参第⼀个位置，增加⼀个当前类类型的指针，叫做this

指针。⽐如Date类的Init的真实原型为， void Init(Date* const this, int year,

int month, int day)

       类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值， this-

>_year = year;

       C++规定不能在实参和形参的位置显⽰的写this指针(编译时编译器会处理)，但是可以在函数体内显

⽰使⽤this指针。

this指针的特性：

1. this指针的类型：类类型* const。
2. 只能在“成员函数”的内部使用。
3. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

class Date
{
public:
  // void Init(Date* const this, int year, int month, int day)
  void Init(int year, int month, int day)
  {
    // this = nullptr;
    // this->_year = year;
    _year = year;
    this->_month = month;
    this->_day = day;
  }
  void Print()
{
  cout << _year << "/" << _month << "/" << _day << endl;
}
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  // Date类实例化出对象d1和d2
  Date d1;
  Date d2;
  // d1.Init(&d1, 2024, 3, 31);
  d1.Init(2024, 3, 31);
  d1.Print();
  d2.Init(2024, 7, 5);
  d2.Print();
  return 0;
}