c++必修：类和对象（一）

放一张c++祖师爷的照片~~

一类和对象

1定义格式

• class为定义类的关键字，Stack为类的名字，{}中为类的主体，注意类定义结束时后⾯分号不能省 略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的⽅法或 者成员函数。 • 为了区分成员变量，⼀般习惯上成员变量会加⼀个特殊标识，如成员变量前⾯或者后⾯加_ 或者 m 开头，注意C++中这个并不是强制的，只是⼀些惯例，具体看公司的要求。 • C++中struct也可以定义类，C++兼容C中struct的⽤法，同时struct升级成了类，明显的变化是 struct中可以定义函数，⼀般情况下我们还是推荐⽤class定义类。 • 定义在类⾯的成员函数默认为inline。

class Calendar
{
public://访问修饰符（access specifier）
//成员函数
	void Init(int year, int month,int day) {
		_year = year;
		_month = month;
		_day = day;

	}

//成员变量
private:
	int _year;
	int _month;
	int _day;

};

其中我们用class定义了Calendar类。其中void Init是类的方法。或者叫成员函数，定义的_year,_month,_day叫做类的属性或成员变量。

我们在定义有些形参时候有习惯定义成成员变量的样子，为了区分成员变量，⼀般习惯上成员变量 会加⼀个特殊标识，如_ 或者 m开头。

比如上面的Inite函数。

2 访问限定符

其中一个封装定义到下一个封装定义为止。

访问限定符有三个，我们现在常用的是public和privite.protected暂时不讨论。

如图我们在定义类的时候对于成员函数和成员变量会用访问限定符来修饰。

其中我们一般用public(公开的)来修饰成员函数，用private(私有的)来修饰成员变量。我们如果想修改成员变量一般调用类内部写的成员函数，而不是随便就能调用。这样就起到了c++封装的效果。 我们也有在类外可以修改的方法，暂时不做讨论

3 类域

• 类定义了⼀个新的作⽤域，类的所有成员都在类的作⽤域中，在类体外定义成员时，需要使⽤ :: 作 ⽤域操作符指明成员属于哪个类域。 • 类域影响的是编译的查找规则，下⾯程序中Init如果不指定类域Stack，那么编译器就把Init当成全 局函数，那么编译时，找不到array等成员的声明/定义在哪⾥，就会报错。指定类域Stack，就是知 道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找。

class Calendar
{
public:
	
	void Init(int year, int month, int day);


private:
	int _year;
	int _month;
	int _day;

};

void Calendar::Init(int year, int month, int day) {
	_year = year;

	_month = year;
	_day = day;


}

还是这段代码，我们把 void Init(int year, int month, int day)函数放在类内部声明了，但是在定义时候要指明是哪个类，也就是类域。void Calendar::Init。

这一步也是起到了封装的效果，假如我们写一个栈的Inite函数，再写一个队列的Inite函数，我们可以写同一个函数名字，只要定义的时候指明不同类域即可，底层实现完全不同。 体现了c嘎嘎的封装性

二实例化

1 实例化概念

• ⽤类类型在物理内存中创建对象的过程，称为类实例化出对象。 • 类是对象进⾏⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，⽤类实例化出对象时，才会分配空间。 • ⼀个类可以实例化出多个对象，实例化出的对象 占⽤实际的物理空间，存储类成员变量。打个⽐⽅：类实例化出对象就像现实中使⽤建筑设计图建造出房⼦，类就像是设计图，设计图规划了有多 少个房间，房间⼤⼩功能等，但是并没有实体的建筑存在，也不能住⼈，⽤设计图修建出房⼦，房 ⼦才能住⼈。同样类就像设计图⼀样，不能存储数据，实例化出的对象分配物理内存存储数据。

int main()
{
Date d1;//实列化对象d1;

Date d2;//实列化对象d2;
return 0;
}

通俗点讲就是我们通过类名 +名称的方法来实例化一个变量，这时候内存才会分配空间。 类定义的时候没有空间，只是纸上谈兵。

2 对象⼤⼩

在这里看我们可以了解到成员函数是不包含在实列化对象中的，例如这个d的大小只要3个整型，12个字节。 那么为什么不能包含成员函数呢？

因为Date实例化d1和d2两个对象，d1和d2都有各⾃独⽴的成员变量

_year/_month/_day存储各⾃的数据，但是d1和d2的成员函数Init/Print指针却是⼀样的，存储在对象 中就浪费了。如果⽤Date实例化100个对象，那么成员函数指针就重复存储100次，太浪费了。这⾥需 其实函数指针是不需要存储的，函数指针是⼀个地址，调⽤函数被编译成汇编指 令[call 地址]。他们共有的方法则定义在其他地方。 这里有点像内联函数是否展开的逻辑

3. this指针

int main() {
	Calendar d1;
	Calendar d2;
	
	d1.Init(2024, 9, 22);
	d2.Init(2024, 9, 23);
	d1.Print();
	d2.Print();

	
}

我们再写一个函数Print.

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

void Init(Calendar* const this, int year, int month, int day)

这个this指针只是被隐藏了。我们不写也会自动加上我们可以不隐藏写成这样 void Init(Calendar* const this,int year, int month, int day) 但是不能写，但是我们可以用this指针验证，其中this就是实例化的对象的指针。

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

		this->_month = year;
		_day = day;


	}

4用c++实现栈

#include<iostream>
#include<assert.h>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	// 成员函数
	void Init(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
	void Pop()
	{
		assert(_top > 0);
		--_top;
	}
	bool Empty()
	{
		return _top == 0;
	}
	int Top()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}
	void Destroy()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	// 成员变量
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
int main()
{
	Stack s;
	s.Init();
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	while (!s.Empty())
	{
		printf("%d\n", s.Top());
		s.Pop();
	}
	s.Destroy();
	return 0;
}

这里用c++70多行代码就实现了。体现了其优越性

三总结

这次课我们了解了c++中的一些特殊的定义和方法，初步认识到了封装的优越性，希望和大家一起进步~~