【爱上C++】详解类与对象1

hello朋友们，这里是勇子.虽说已经注册账号1年了，但真正踏上博客之路还是在这几天，我会把博客的内容做的尽可能的易懂，清晰。
OK，话不多说今天我来学习C++中的类与对象1。

1.类的引入

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，
也可以定义函数。比如：之前在数据结构初阶中，用C语言方式实现的栈，
结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。
1
2
3

typedef int DataType;
struct Stack
{
	void Init(size_t capacity)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(const DataType& data)
	{
		// 扩容
		_array[_size] = data;
		++_size;
	}
	DataType Top()
	{
		return _array[_size - 1];
	}
	void Destroy()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
	DataType* _array;
	size_t _capacity;
	size_t _size;
};
int main()
{
	Stack s;
	s.Init(10);
	s.Push(1);
	s.Push(2);
	s.Push(3);
	cout << s.Top() << endl;
	s.Destroy();
	return 0;
}

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
44
45
46
47
48
49
50

上面结构体的定义，在C++中更喜欢用class来代替。
1

2.类的定义

格式：

class className
{
// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号
1
2
3
4

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。
类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。
1
2

类的两种定义方式：

• 1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内
     联函数处理。

//声明和定义全部放在类体里
class Person
{
public:
	void showInfo()
	{
		cout<<_name<<"-"<<_sex<<"-"<<_age<<endl;
	}
public:
		char* _name;
		char* _sex;
		int _age;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 2.类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

//声明放在person.h文件
class Person
{
public:
	void showInfo();
public:
		char* _name;
		char* _sex;
		int _age;
};

//定义放在类的视线文件person.cpp文件中
#include<"person.h">
void Person::showInfo()
{
	cout<<_name<<"-"<<_sex<<"-"<<_age<<endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

一般情况下，更期望采用第二种方式。为了方便演示，笔者在此用方式一。
1

成员变量命名规则的建议：

class Date
{
public:
	void Init(int year)
	{
		_year = year;
	}
private:
	int _year;
};
// 或者这样
class Date
{
public:
	void Init(int year)
	{
		mYear = year;
	}
private:
	int mYear;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

一般C++成员前面加_都代表是内部的
函数参数和成员变量尽量不要重命。以免弄混。
1
2

3.类的访问限定符

4.类访问限定符

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

class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout << _name << " " << _gender << " " << _age << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5.类的实例化

用类类型创建对象的过程，称为类的实例化

• 1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。
     谜语：“年纪不大，胡子一把，主人来了，就喊妈妈” 谜底：山羊
• 2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

int main()
{
	Person._age = 100; // 编译失败：error C2059: 语法错误:“.”
	return 0;
}
1
2
3
4
5

Person类是没有空间的，只有Person类实例化出的对象才有具体的年龄。

• 3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间.

class Person
{
public:
	void showInfo();
public:
		char* _name;
		char* _sex;
		int _age;
};

void Test()
{
	Person man;
	man._name="jack";
	man._age=10;
//要先实例化出一个 man;然后这个实例化的对象才占空间，
//才有name，age，sex；
	......
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

6.类对象大小的计算

类的大小通常由它的非静态成员变量决定。成员函数（包括静态和非静态成员函数）不占用类对象的大小，因为成员函数在内存中只有一份，它们不属于任何特定的对象实例，而是与类本身相关联。成员函数在编译时被转换为指向函数代码的指针，并存储在类的元信息中，而不是对象的内存布局中。
要计算类对象的大小，可以使用sizeof运算符。sizeof运算符返回类型或对象在内存中的大小（以字节为单位）。
分以下四种情况来介绍：
1
2
3

1. 空类
   结论：空类不含任何成员变量，大小通常为1字节，这1个字节的空间是系统为该类的对象创建的一个占位符，表示该对象仅仅是存在而已，而没有实际内容。在大多数编译器和平台上，即使类没有成员变量，也会为其分配至少1字节的空间。

#include <iostream>  
using namespace std;  
class EmptyClass {

};  
int main() {  
    cout << "Size of EmptyClass: " << sizeof(EmptyClass) << " bytes" << endl;  
    return 0;  
}//打印结果为 1
1
2
3
4
5
6
7
8
9

2. 仅有常规函数、无成员变量类
   成员函数（包括静态和非静态成员函数）不会影响类对象的大小。成员函数只是类的接口，它们在类的元信息中存储为指向函数代码的指针，不占用对象内存。

#include <iostream>  
using namespace std;  
  
class FunctionOnlyClass {  
public:  
	 常规函数（非静态成员函数）  
    void printHello() {  
        cout << "Hello from FunctionOnlyClass!" << endl;  
    }  
};  
  
int main() {  
    cout << "Size of FunctionOnlyClass: " << sizeof(FunctionOnlyClass) << " bytes" << endl;  
    FunctionOnlyClass obj;  
    obj.printHello(); // 调用成员函数  
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3. 含有一般成员变量类
   类的大小由其非静态成员变量的大小决定，并可能受到内存对齐的影响。内存对齐是编译器为了提高访问效率而进行的优化，它可能会在成员变量之间插入填充字节

#include <iostream>
using namespace std;
class A {
public:
	A(int x=0) {
		cout<<"A"<<x<<endl;
	}
	void printA() {
		cout<<"Hello A";
	}
private:
	char Data1[3];
	int Data2;
};
class B :public A{
public:
	B(int x=0) {
		cout<<"B"<<x<<endl;
	}
	void printB() {
		cout<<"Hello B";
	}
private:
	char Data1[3];
	int Data2;
};
 
class C : public B{
public:
	C(int x=0) {
		cout<<"C"<<x<<endl;
	}
	void printC() {
		cout<<"Hello C";
	}
private:
	char Data1[3];
	int Data2;
};
 
int main() {
	A a;
	B b;
	C c;
	cout<<"size of a:"<<sizeof(a)<<endl;//8
	cout<<"size of b:"<<sizeof(b)<<endl;//16
	cout<<"size of c:"<<sizeof(c)<<endl;//24
	return 0;
}
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
44
45
46
47
48
49

4. 含静态成员变量的类
   静态成员变量属于类本身，而非类的实例。因此，它们不占用类对象的大小，而是在类的外部静态存储区分配空间。

#include <iostream>  
using namespace std;  
  
class StaticMemberClass {  
public:  
    static int staticVar; // 静态成员变量,加了static
};  
  
int StaticMemberClass::staticVar = 0; // 静态成员变量的定义  
  
int main() {  
    cout << "Size of StaticMemberClass: " << sizeof(StaticMemberClass) << " bytes" << endl;  
    // 可以通过类名直接访问静态成员变量  
    cout << "StaticVar value: " << StaticMemberClass::staticVar << endl;  
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个例子中，即使StaticMemberClass有一个静态成员变量staticVar，类对象的大小仍然不受其影响。静态成员变量staticVar在程序的静态存储
区分配空间，不属于任何对象实例。
1
2

7.结构体内存对齐规则

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

另外这篇文章也写的非常详细——>内存对齐详解

面试题：

1. 结构体怎么对齐？ 为什么要进行内存对齐？
2. 如何让结构体按照指定的对齐参数进行对齐？能否按照3、4、5即任意字节对齐？
3. 什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景

回答：

• 问题1：
  结构体对齐是编译器在内存布局中自动处理的一个过程，确保结构体中的每个成员都按照特定的规则（通常是其类型大小的整数倍）进行对齐。这样做的主要原因有以下几点：
  硬件访问效率：大多数硬件平台在访问对齐的内存地址时效率更高。如果数据没有对齐，硬件可能需要进行额外的操作才能访问数据，这降低了性能。
  安全性：未对齐的内存访问可能导致硬件异常或未定义行为，尤其是在某些严格对齐要求的平台上。
  可移植性：不同的硬件平台或编译器可能有不同的对齐要求。确保结构体正确对齐有助于代码在不同平台上的可移植性。

• 问题2：
  在C和C++中，可以使用编译器特定的属性或指令来控制结构体的对齐。例如，在GCC中，可以使用__attribute__((aligned(n)))来指定对齐参数。例如：

struct MyStruct {  
    int a;  
    char b;  
} __attribute__((aligned(4)));
1
2
3
4

上述代码中的MyStruct结构体将按照4字节对齐。
对于任意字节对齐，如3、4、5字节，这通常取决于编译器的支持。在某些编译器中，可以指定任意的对齐值。但是，需要注意的是，不是所有的对齐值都是有效的，特别是在某些硬件平台上，可能有一些限制。
如果编译器不支持特定的对齐值，可能需要使用额外的填充字节或结构体成员来手动控制对齐。

• 问题3：
  大小端（Endian）是描述计算机系统中字节序的一个术语。大端（Big-Endian）表示高位字节存储在内存的低地址处，而低位字节存储在内存的高地址处；小端（Little-Endian）则相反，低位字节存储在内存的低地址处，高位字节存储在内存的高地址处。

//1.利用当前一个高类型的变量给其赋值，然后取到其低地址，查看其存储的数据。
#include<stdio.h>
void CheckSystem1()
{
	int a = 1;
	int num = (*(char*)&a);//&a 取出a的地址；  (char*)&a 代表a变量地址的第一个字节的地址
	printf("%d\n", num);//(*(char*)&a) 解引用取出第一个字节保存的内容
	if (num == 1)
		printf("小端\n");
	else
		printf("大端\n");
}
int main()
{
	CheckSystem1();
	getchar();
	return 0;
}
//2.联合体特性
int CheckSystem2()
{
	union check
	{
		int num;
		char a;//2个变量公用一块内存空间，并且2个变量的首地址相等
	}b;
	b.num = 1;//1存放在变量num的低位
	return (b.a == 1);//当变量a=1，相当于将数据的低位存到了内存的低地址处，即小端模式
}
int main()
{
	int c = CheckSystem2();
	printf("c : %d\n", c);
	getchar();
	return 0;
}

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

解释： 这段代码首先定义了一个 int 类型的变量 a 并赋值为 1。在大多数现代系统上，int 类型通常至少为 4 字节（32> 位）。数字 1 在二进制表示中只有一个位是 1，其余位都是 0。 00000000 00000000 00000000 00000001 (32-bit int with value 1) 接着，代码将 a 的地址转换为一个 char 类型的指针，然后解引用这个指针来得到 a 的第一个字节。在 printf 语句中，这个字节的值被打印出来。 如果运行代码的机器是小端的，那么 int变量的最低有效字节将位于内存中的最低地址。对于数字 1，其最低有效字节是00000001，因此 num 的值将为 1。
如果运行代码的机器是大端的，那么 int 变量的最高有效字节将位于内存中的最低地址。对于数字 1，其最高有效字节包含所有零，因此 num 的值将不是 1。 最后，根据num 的值判断并打印出是大端还是小端。

第二段代码（CheckSystem2） 在这段代码中，定义了一个联合体（union）check，它包含一个 int 类型的成员 num 和一个 char 类型的成员 a。由于联合体的特性，num 和 a 共享同一块内存空间，并且它们的首地址是相同的。 当给 b.num 赋值为1 时，这个值在内存中的表示取决于机器的端序。如果机器是小端的，那么 int 变量的最低有效字节将位于内存的最低地址，并且这个字节的值将是 1。由于 b.a 与 b.num 的首地址相同，因此 b.a 的值也将是 1。 如果机器是大端的，那么 int
变量的最高有效字节将位于内存的最低地址，并且这个字节的值不会是 1。因此，b.a 的值也不会是 1。 最后，通过比较 b.a 是否等于 1来返回一个布尔值，这个布尔值在 main 函数中被打印出来。如果返回 true（即 1），则表示机器是小端的；如果返回 false（即0），则表示机器是大端的。

8.this指针

C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

//所有的成员函数的参数 都比看到的多一个，  就是this指针
#include<iostream>
using namespace std;
class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;//this->_year=year;
		_month = month;
		_day = day;
	}

	// 不能显示的写实参和形参
	// void Print(Date* const this)
	void Print()
	{
		//this = nullptr;
		cout << this << endl;
		// 但是可以在类里面显示的使用
		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year;     // 年
	int _month;    // 月
	int _day;      // 日
};

int main()
{
	Date d1;
	d1.Init(2023, 10, 19);
//编辑器视角下是 d1.Init(&d1,2023,10,19)
//这里，&d1是d1对象的地址，它会被隐式地作为 this 指针传递给 Init 函数。然后，在 init 函数内部，编译器会像这样使用 this 指针:
//       初始化函数里面     //this->_year=year;
	Date d2;

	d1.Print(); // d1.Print(&d1);
	d2.Print();
	return 0;
}
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指针特性

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