C C++最新C++ 类和对象（上）------超详细解析，小白必看系列(1)，神级C C++进阶笔记

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

struct Student
{
	void Init(const char* name, const char* gender, int age)
	{
		strcpy(_name, name);
		strcpy(_gender, gender);
		_age = age;
	}
	void Print()
	{
		cout << _name << " " << _gender << " " << _age << endl;
	}
//这里并不是必须加_
//习惯加这个，用来表示成员变量
	char _name[20];
	char _gender[3];
	int _age;
};
int main()
{
	Student s1;
	s1.Init("张三", "男", 23);
	s1.Print();
	return 0;
}

运行结果展示：

⚠ 注意1：在 Init() 函数中出现了 const char* name ，可能很多老铁会疑惑这里为什么会出现 const 呢 ，其实是因为 **strcpy**函数的定义

**⚠ 注意2：**在类中，老铁会发现，我的大量成员变量前面会加入 **“_” ,****这是由于 C++  有一个惯例，成员变量通常前面加 _变量  ，****以便于区分 类函数中的形参变量。**举个例子：

class Data
{
public:
	void Init(int year, int mouth, int data)
	{
		_year = year;
		_mouth = mouth;
		_data = data;
	}
	void Print()
	{
		// 这里的 _year 不是 private 中的_year, 而是在main函数中定义的_year 
		cout << _year << " " << _mouth << " " << _data << endl;
	}
private:
	// 声明 这里的变量并没有空间，用不了
	int _year;
	int _mouth;
	int _data;
};

上述代码 void Init() 函数中 ，如果不加 “_year” 函数中的形参变量会分不清

**⚠ 注意3：**这里的成员变量可以定义在任何位置，不会像C语言那样受到约束，因为C++这里把struct升级成了类，类是一个整体，它会在这个整体内寻找。虽然C++把struct升级成了类，不过C++还是喜欢用class来代替struct以此来定义类。

int main()
{
	Student s1;
	return 0;
}

我们把Student叫做类名，先前C语言s1叫做变量，而到了C++要称之为对象。

三、类的定义

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

• class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号。

• 类中的元素称为类的成员：类中的数据称为类的属性或者成员变量; 类中的函数称为类的方法或者成员函数。

类的定义有两种方式，具体内容等到下文的类的作用域会讲到。

四、类的访问限定符及封装

💦访问限定符 （重点！！！！）

要知道我类里定义的东西不是都给你随便用的如下：

1️⃣ ：我若想把里面的东西给你用就定义成公有（public:）

2️⃣ ：不想给你用的就定义成私有（private:）

3️⃣ ：要保护起来的就定义成（protect:）

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

• 访问限定符说明：（**都蛮重要的**）

1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4. 如果后面没有访问限定符，作用域就到}类结束
5. class的默认访问权限为private，struct为public**(因为struct要兼容C）**

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

接下来做具体演示：

• class默认private：

• struct默认public：

• public：

• private：

• proteced：

现阶段我们认为protected公有和private私有的作用是一样的，都是在类外不能访问。这里不再赘述。

• 【面试题】

问题：C++中struct和class的区别是什么？
解答：C++需要兼容C语言，所以C++中struct可以当成结构体去使用。另外C++中struct还可以用来定义类。和class是定义类是一样的，区别是struct的成员默认访问方式是public，class是的成员默认访问方式是private。

💦封装

• 【面试题】 面向对象的三大特性：封装、继承、多态。

**在类和对象阶段，我们只研究类的封装特性，那什么是封装呢？
封装：**将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

我们都清楚C语言的数据和方法是分离的，我们以栈为例：

//C语言的数据和方法是分离的
struct Stack
{
	int* _a;
	int _top;           // 数据
	int _capacity;
};
void StackInit(struct Stack* ps)
{}
void StackPush(struct Stack* ps, int x)             // 方法
{}
int StackTop(struct Stack* ps)
{}
int main()
{
	struct Stack st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 3);
	StackPush(&st, 5);
	return 0;
}

像C语言这样数据和方法分离会存在一个巨大的问题：太过自由！我没办法去对它很好的管理，就比如我现在想访问栈顶的数据，如若是C语言，我们就可以这样写：

	printf("%d\n", StackTop(&st));  //规范
	printf("%d\n", st._a[st._top]); //不规范

按理来说，第一行的代码才是正确的，合理的，中肯的访问形式，第二行代码直接用结构去操纵成员，虽然也可以，但是会涉及到一个问题：我对top到底是栈顶元素还是栈顶元素的下一个位置？
(如果初始化里的top给的是0，那st.top就是栈顶元素的下一个位置，会越界，如果是-1，那么刚好就是栈顶元素）**此时就会出现误用。**相反直接调用StackTop函数就完全不会出现这个问题，因为我在之前就已经处理好了，返回的值必是栈顶元素。

• 由此可见，C语言在这一方面太过自由了，接下来来看看C++是如何来解决的。

这就需要用到封装了。C++设计出了类，类里除了可以定义成员变量，还可以定义函数，所以我们就可以把上述栈的初始化，插入，取栈顶全放到类里，也就实现了数据和方法封装到一起。

//1、数据和方法封装到一起，类里面
//2、想给你自由访问的设计成公有，不想给你访问的设计成私有
class Stack
{
public:
	void Init()
	{}
	void Push(int x)
	{}
	int Top(struct Stack* ps)
	{}
private:
	int* _a;
	int _top;
	int _capacity;
};

并且此段代码还实现了我想给你访问的就设计成公有，不想给你访问的就设计成私有。此时就完美避免了C语言过渡自由懒散的弊端，此时就不能再像C语言那样直接访问成员变量了，而只能用成员函数。

int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	st.Push(3);
	st.Push(4);
	cout << st.Top() << endl;
	//cout << st._a[st._top] << endl; //err
	return 0;
}

C++通过强制的就能让用的人更规范。并且一般情况设计类，成员数据都是私有或保护，想给你访问的函数是公有，不想给你访问的是私有或保护。

🍉****综上，C++的封装本质上就是一种更严格的管理。
就好比如一件珍藏在博物馆里的艺术品，在C语言中，这些艺术品就像是没有受到任何权限限制，也没有工作人员监管，供游客观赏时间长了可能艺术品被人偷走了都不知道，而在C++中，这些艺术品就受到了保护，有工作人员的巡逻，有摄像头的抓拍，也有玻璃罩将其封装到安全范围内。

五、类的作用域

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

如下我们定义两个类（栈和队列）

//栈
class Stack
{
public:
	void Push(int x)
	{}
};

//队列
class Queue
{
	void Push(int x)
	{}
};

这两个类中，我都定义了一个Push函数，此时编译器不会报错，这两个Push函数也不会构成函数重载，因为Stack类和Queue类是完全两个不同的作用域。

再比如我在Stack.h声明如下内容：

现在想在Stack.cpp文件里进行定义，就要指定作用域，否则会报错：

讲到这，我们就可以回过头来想想前面铺垫过的一个问题：

• 类的定义方式1：

**⚠ 注意：**成员函数如果在类中定义，编译器可能会将其当成内联函数处理。因此，一般情况下，短小函数可以直接在类里面定义，长一点的声明和定义分离。

• 方式2：声明放在.h文件中，类的定义放在.cpp文件中

此方式就如同上文类的作用域一开始放出来的两张截图。

• **补充：**类成员变量仅仅只是声明，不是定义！！因为没有开辟空间。

// 变量的声明和定义 在于是否给它开空间
class Data
{
public:
	void Init(int year, int mouth, int data)
	{
		_year = year;
		_mouth = mouth;
		_data = data;
	}
	void Print()
	{
		// 这里的 _year 不是 private 中的_year, 而是在main函数中定义的_year 
		cout << _year << " " << _mouth << " " << _data << endl;
	}
private:
	// 声明 这里的变量并没有空间，用不了
	int _year;
	int _mouth;
	int _data;
};
// 类  和  对象 的关系   1 v 多 ：一个类就可以有多个对象
// 设计图   房子
int main()
{
	// 这里叫定义
	// 对象的定义，也叫做，对象的实例化
	// d1 就是对象
	Data d1;
	// 错误写法，这里是声明，不是定义，没有开空间
	//Data::_year = 1;
	cout << sizeof(d1) << endl;   // 12  有三个成员变量
	Data d2;
	d2.Init(2022, 10, 18);
	d1.Init(2023, 10, 18);
	d1.Print();
	d2.Print();
	return 0;
}

六、类的实例化

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

1. 类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

七、类对象模型

💦如何计算类对象的大小

现在给出这样一个类：

class Stack
{
public:
	//在类里面定义
	//在类里定义的函数默认是内联
	void Init()
	{
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
	//在类里面声明
	void Push(int x);
	void Pop();
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st;
	st.Init();
	cout << sizeof(st) << endl; //12
}

这里我用类定义了一个对象st，现在想求出对象的大小，运行的结果为12，为何为12呢？，这里和C语言求结构体的大小有点相似，不过C语言的结构体不准有函数，方便计算，可是C++里的类里有函数还要成员变量，那么一个类的对象中包含了什么？如何计算一个类的大小？看下文：

💦类对象的存储方式猜测

• 猜测1：对象中包含类的各个成员

缺陷：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。那么如何解决呢？

• **猜测2：**只保存成员变量，成员函数存放在公共的代码段

通过我们刚才得知的结果（12）来看，类对象的存储方式采用的是第二种方式。
综上类大小的计算不考虑成员函数。

• 清楚了类的存储方式，来做几个题：

// 类中既有成员变量，又有成员函数
class A1 {
public:
	void f1() {}
private:
	int _a;
	char _ch;
};
// 类中仅有成员函数
class A2 {
public:
	void f2() {}
};
// 类中什么都没有---空类
class A3
{};
int main()
{
	A1 a1;
	A2 a2;
	A3 a3;
	cout << sizeof(a1) << endl; // 8
	cout << sizeof(a2) << endl; // 1
	cout << sizeof(a3) << endl; // 1
	return 0;
}

• sizeof(a1)：  8     sizeof(a2)：  1     sizeof(a3)：  1

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

A3

{};
int main()
{
A1 a1;
A2 a2;
A3 a3;
cout << sizeof(a1) << endl; // 8
cout << sizeof(a2) << endl; // 1
cout << sizeof(a3) << endl; // 1
return 0;
}

* sizeof(a1)：  8     sizeof(a2)：  1     sizeof(a3)：  1

[外链图片转存中…(img-Tu8aPwNy-1715712937792)]
[外链图片转存中…(img-7nU97b0U-1715712937792)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取