C++初阶--类与对象（1）

类的引入

在c语言中，我们会这样写一个栈：

struct Stack
{
	int* a;
	int top;
	int capacity;
};

void StackInit(struct Stack* ps);
void StackPush(struct Stack* ps, int x);
1
2
3
4
5
6
7
8
9

先写出一个栈的结构体出来，然后写出有关栈的函数出来；我们会把对于栈的操作部分拆分出来，所以我们说C语言是面向过程的；

而在C++中，对于结构体来说，还可以把函数也写进结构体中；
并且对于结构体变量类型，可以省略struct

#include
struct Stack
{
	int* a;
	int top;
	int capacity;

	void Init()
	{
		a = (int*)malloc(sizeof(int)*4);
		top = 0;
		capacity = 4;
	}
	void Push(int x)
	{
		//空则扩容
		if (top == capacity)
		{
			int newcapacity =  capacity * 2;

			int* New = (int*)realloc(a, sizeof(int) * (newcapacity));
			if (New == nullptr)
			{
				perror("Newsapce Fail");
				exit(-1);
			}
			a = New;
			capacity = newcapacity;
		}
		//插入
		a[top] = x;
		top++;
	}
};

int main()
{
	Stack s1;
	s1.Init();
	s1.Push(5);
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

上面的这种struct的定义，C++更喜欢使用class来代替；

类的定义

class Student
{

};
1
2
3
4

class是定义一个类的关键字，Student是类的名字，括号内是类的主体；大体与struct是相似的；
在主体部分，类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

class Stack
{
private:
	int* a;
	int top;
	int capacity;
public:
	void Init()
	{
		a = nullptr;
		top = 0;
		capacity = 4;
	}
	void Push(int x)
	{
		//空则扩容
		//...
		//插入
		a[top] = x;
		top++;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

private和public是访问限定符。

对于类定义的写法，一般有两种，第一种的像上面的一样，将成员函数的内容直接在类中写出，另一种就是将成员函数声明放在类中，函数的定义写在另一个文件中。

注意：第一种方法中，将函数直接在类中定义，会把函数的内容直接在类中展开，也就是说，直接在类中定义的话相当于是一个内联函数，所以如果函数内容较长时，还是建议写第二种方法；

访问限定符

C++通过访问限定符，用来控制不同代码块之间的访问权限，它们决定了类中的成员是否可以被访问和使用。

public：被public修饰的成员可以被任意代码块进行访问。

protected：被protected修饰的成员可以被当前类、同一包类、以及之类进行访问。
private：被pricate修饰的成员只能被当前类内部的其他成员所访问。

访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

这也就可以解释class和struct的区别：
C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。
所以我们会在class类中写清楚private和pubilc。

类成员的注意事项

变量名的冲突

class Date
{
private:
	//声明
	int _year;
	int _month;
	int _day;
public:
	void Init(int year, int month, int day)
	{
		/*year = year;
		month = month;
		day = day;*/
		//错误的，变量名冲突

		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

在定义成员变量名的时候，需要注意成员变量名是否冲突，因为它们都在一个作用域中，所以在这里建议对于成员变量名最好多加一个符号来表示这是成员变量的，用来区分变量名。

类的实例化

类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；

int main()
{
	Date d1;
	Date d2;
	//....
}
1
2
3
4
5
6

上面的d1，d2我们称之为类的对象。
一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量。

类成员的声明与定义

struct Stack
{
	int* a;
	int top;
	int capacity;
};
int main()
{
	Stack s1;
	s1.capacity = 10;
	//正确的
	Date d1;
	d1._year=10;
	//错误的
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在上面的限定符已经讲过，Date的成员变量都是private中的，无法在作用域外进行访问。而Stack是struct定义的，所以允许我们进行访问。但这里要注意的是Date中的成员变量，实际上只是声明而已，实际上的定义是在创建对象时定义的。

我们可以这样试验：

在public限定符中写一个成员变量，

它是可以在作用域外被使用的，因为它是公有的；

而我们定义多个对象时，

它们也可以打印出对应的内容。
这就说明了对于类的成员变量来说，在类中都只是声明而已，无论在private还是public，那只是限定符而已。定义都必须要在对象中进行，这样在多个对象中进行访问才不会产生冲突。

而对于成员函数来说，无论你是在类中定义，还是类外定义，你都会有一个函数地址，存在多个对象时，只需要调取你的地址，在栈区中建立栈帧即可。

所以我们可以总结：类的成员变量的定义均在对象中，而类的成员函数，不用在对象中进行定义。

类的大小

class Date
{
private:
	//声明
	int _year;
	int _month;
	int _day;
public:
	void Init(int year, int month, int day)
	{
		
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	
};
class SizeNuLL
{

};
class Size1NULL
{
	class Size2NULL
	{

	};
};
int main()
{
	cout << sizeof(d1) << endl;//12
	SizeNuLL s1;
	cout << sizeof(s1) << endl;//1
	Size1NULL s2;
	cout << sizeof(s2) << endl;//1
	无成员变量的类，对象大小开一个字节，这个字节不存储有效位
	用来标识的对象存在过
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

这里的计算只计算成员变量，计算方式与结构体的计算方式是一样的，会利用到内存对齐的规则。
而对于无成员变量的类来说，对象大小开一个字节，这个字节不存储有效位，用来标识的对象存在过。

this指针

class Date
{
private:
	//声明
	int _year;
	int _month;
	int _day;
public:
	int dd;
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	
};
int main()
{
	Date d1;
	d1.Init(2023, 10, 19);
	d1.Print();
	Date d2;
	d2.Init(2022, 9, 8);
	d2.Print();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

上述代码中：成员函数的参数中我们没有引用相关对象的参数，对于不同对象中，它是怎么识别的呢？
C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编
译器自动完成。

当指针为空时：

Date* d3 = nullptr;
	//错误的，对象指针为空，this指针也为空
	d3->Init(2023, 10, 20);
	d3->Print();
	Date* d4;
	//错误的，d4没有初始化，指针相当于指向空
	d4->Init(2023, 10, 21);
	d4->Print();
1
2
3
4
5
6
7
8

特性

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
   

2. 只能在“成员函数”的内部使用

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递
5. this指针存储的是当前被调用的成员函数对应的对象的地址，也就是在栈帧中。（一些编辑器会存储在寄存器中，如VS2022）

总结

类的成员变量实际上只是声明，定义会在变量中定义（当创建了一个类对象时）；成员函数不在类对象里面，它属于公共部分，也就是每个类对象都可以调用它； 指针没有初始化和指向空，实质上都是没有指向一个存在的类对象，这样就导致指针不明确；在成员函数里面会有一个隐藏的this指针，用来表示指向成员变量，我们在编写代码不能显示this该步骤已经由编译器自动写好了，在成员函数中就可以直接调用变量；这也就说明指针为空的情况下，this指针找不到已有的成员变量；