类和对象（上）

类和对象（上）

一、类的定义

1.类定义格式

class Stack
{
public:
    // 成员函数(方法)
	void Init(int n = 4)
    {
    }
    void Push(int x)
    {
    }
private:
    // 成员变量
    int* _array;
    size_t _capacity;
    size_t _top;
};	// 注意有分号，表示一个完整的语句

• class为定义类的关键字，Stack为类的名字（自定义），{}中为类的主体即一个类域，注意类定义结束时后面分号不能省略（与struct一致）。类体重内容称为类的成员：类中的变量称为类的属性或成员变量；类中的函数称为类的方法或者成员函数。

• 为了区分成员变量，一般习惯上成员变量会加一个特殊标识，如成员变量前面或者后面加"_"或者"m"开头，具体编码风格看公司要求。

  #include <iostream>
  using namespace std;
  class Date
  {
      
    public:
    	void Init(int year, int month, int day)
      {
          _year = year;	// 成员变量 + _ 利于区分
          _month = month;
          _day = day;
      }
    private:
      int _year;
      int _month;
      int _day;
  };
  int main()
  {
      Date A;
      A.Init(2024,7,17);
  	return 0;
  }
  

• C++中的struct也可以定义类，是一个公共类，C++兼容C中struct的用法，同时struct升级成了类。

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

2.访问限定符

• C++一种实现封装的方式，用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供外部的用户使用。
• public修饰的成员在类外可以直接被访问；protected和private修饰的成员在外不能直接被访问。protected和private在继承中才能体现出区别。
• 访问权限作用域从该访问限定符出现的位置开始知道下一个访问限定符出现时为止，如果后面没有访问限定符，作用域就到 } 即类结束。
• class定义成员没有被访问限定符修饰时默认为private，struct默认为public。
• 一般成员变量都会被限制为private/protected，需要给别人用的成员函数会放为public。

3.类域

• 类定义了一个新的作用域，类的所有成员都在类的作用域中，在类体外定义成员时，需要使用 " :: " 作用域操作符指明成员属于哪个类域。
• 类域影响的是编译的查找规则与namespace的命名域相似。当定义和申明分开时，就得采用次查找规则。

示例：

#include <iostream>
using namespace std;
class Stack
{
public:
	void Init(int n = 4);

	void Push(int x);
private:
	int* _arr = nullptr;
	size_t _capacity;
	size_t _top;
};
void Stack::Init(int n)
{
	_arr = (int*)malloc(sizeof(int) * n);
	if (_arr = nullptr)
	{
		perror("malloc申请空间失败");
		return;
	}
	_capacity = n;
	_top = 0;
}
int main()
{

	return 0;
}

三、实例化

1.实例化概念

• 用类类型在物理内存中创建对象（定义成员变量）的过程，成为实例化对象。
• 类是对象进行一种抽象描述，是一个模型一样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，用类实例化出对象时，才会分配空间。
• 一个类可以实例化出多个对象，实例化出的对象占实际的物理空间，存储类成员变量。

#include <iostream>
using namespace std;
class Date
{
    
  public:
  	void Init(int year, int month, int day)
    {
        _year = year;	// 成员变量 + _ 利于区分
        _month = month;
        _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(2024,7,17);
    d1.Print();
    d2.Init(2024,7,18);
    d2.Print();
	return 0;
}

2.对象大小

类实例化出的每个对象，都有独立的数据空间，所以对象中肯定包含成员变量，那么成员函数是否包含？

首先函数被编译后是一段指令，对象没办法存储，这些指令存储在一个单独的区域（代码段），那么对象中非要存储的话，只能是成员函数的指针。

其次对象中存储指针是不必要的，例如Date类实例化d1和d2两个对象，d1和d2都有各自独立的成员变量_year/_month/_day存储各自的数据，但是d1和d2的成员函数Init/Print指针却都是一样的，存储在对象中就浪费了。并且函数指针是不需要存储的，函数指针是一个地址，调用函数被编译成汇编指令[call地址]，其实编译器在编译链接时，就要找到函数的地址，不是在运行时找，只有动态多态是在运行时找，就需要存储函数地址。

综上所述，对象只存储成员变量，同时C++规定实例化的对象符合内存对齐的规则（与C语言的struct内存对齐规则一致）。

内存对齐规则：

• 第一个成员在与结构体偏移量为0的地址处
• 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
• 注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值
• VS中默认对齐数为8
• 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐数取最小）的整数倍。
• 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

内存对齐规则就是经典的利用空间换时间。CPU为了识别各个变量的定义位置，无法任意位置进行数据读写，所以硬件上设计CPU每次以一定的范围读取数据。我们对下面两种方式进行讨论。当我们采用方法一时，我们访问int类型的变量需要读两次，而方法二只需要读一次，虽然浪费了空间，但是大大提高了时间效率，这就是典型的空间换时间的例子。

示例：

#include <iostream>
using namespace std;
class A
{
public:
	void Print()
	{
		cout << "class A" << endl;
	}
private:
	char _ch;
	int _i;
};

class B
{
public:
	void Print()
	{
		cout << "class B" << endl;
	}
};

class C
{
};

int main()
{
	A a;
	B b;
	C c;
	cout << sizeof a << endl;
	cout << sizeof b << endl;
	cout << sizeof c << endl;
	return 0;
}

从上面程序的运行结果我们可以看到没有成员变量的B和C类对象大小是1。这里给一个字节是为了占位标识对象的存在，毕竟对象也是实例化过的。

综上所述：对象大小与成员变量相关且符合内存对齐规则，与成员函数无关（除了动态多态）。并且当没有成员变量的时候，对象大小为1。

三、this指针

Date类中有Init与Print两个成员函数，函数题中没有关于不同对象的区分，那么当d1调用Init和Print时，该函数如何知道应该访问的是d1对象还是d2对象的数据呢？所以C++给了一个隐含的this指针解决这里的问题。

编译器编译后，类的成员函数默认都会在形参第一个位置，增加一个当前类类型的指针，叫做this指针。比如Date类的Init的真实原型为：

// 编译器会报错
// error C2143: 语法错误: 缺少“)”(在“this”的前面)
// error C2143: 语法错误: 缺少“;”(在“this”的前面)
// error C2059: 语法错误:“this”
// error C2059: 语法错误:“)”
// error C2334: “{”的前面有意外标记；跳过明显的函数体
// error C2660: “Date::Init”: 函数不接受 4 个参数
#include <iostream>
using namespace std;
class Date
{
 public:
    void Init(Date* const this, int year, int month, int day)
	{
    this->_year = year;
    this->_month = month;
    this->_day = day;
	}
 private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1;
    d1.Init(&d1 ,2024, 7, 18);	// 传入d1的地址
	return 0;
}

但是C++规定不能再实参和形参的位置显示的写this指针（编译时编译器会处理），但是可以在函数体内显示使用this指针。如：

void Init(int year, int month, int day)
{
    this->_year = year;
    this->_month = month;
    this->_day = day;
}

判断下面程序的运行结果（编译报错、运行崩溃、正常运行）

示例一：

#include<iostream>
using namespace std;
class A
{
public:
	void Print()
	{
		cout << "A::Print()" << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Print();	// 注意！ 访问成员函数时，传递的的成员的地址，所以没有解引用空指针，故不报错，正常运行。
	return 0;
}

正常运行

示例二：

#include<iostream>
using namespace std;
class A
{
public:
	void Print()
	{
		cout << "A::Print()" << endl;
        cout << _a << endl;	// 注意 _a真实原型为 this->_a 所以对this指针进行了解引用，而this指针为p指针即为空指针。
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Print();	
	return 0;
}

运行崩溃（解引用了空指针）

四、C++面向对象相较C语言的优势

面向对象三大特征：封装、继承、多态。

space std;
class A
{
public:
	void Print()
	{
		cout << "A::Print()" << endl;
        cout << _a << endl;	// 注意 _a真实原型为 this->_a 所以对this指针进行了解引用，而this指针为p指针即为空指针。
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Print();	
	return 0;
}

运行崩溃（解引用了空指针）

四、C++面向对象相较C语言的优势

面向对象三大特征：封装、继承、多态。