2024年C C++最全【 C++ 】类和对象（上(1)，2024年最新一起“干完”这份300页1000道面试题-CSDN博客

本文链接：https://blog.csdn.net/2401_84978588/article/details/138773999

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

{
//C语言不typedef只能这样定义
struct Student s1;
//C++可以这样
Student s2;
return 0;
}
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(“张三”, “男”, 18);
s1.Print();
return 0;
}
![](https://img-blog.csdnimg.cn/e4a2957bead14ba599db4dc3ce695db8.png)


* 注意：


这里的成员变量可以定义在任何位置，不会像C语言那样受到约束，因为C++这里把struct升级成了类，类是一个整体，它会在这个整体内寻找。


虽然C++把struct升级成了类，不过C++还是喜欢用class来代替struct以此来定义类。


* 此段代码中：
int main()
{
Student s1;
return 0;
}
我们把**Student**叫做**类名**，先前C语言**s1**叫做变量，而到了C++要称之为**对象**。

3、类的定义

class className
{
	// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号
class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号。
类中的元素称为类的成员：类中的数据称为类的属性或者成员变量; 类中的函数称为类的方法或者成员函数。

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

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

访问限定符

要知道我类里定义的东西不是都给你随便用，我若想把里面的东西给你用就定义成公有（public:）。不想给你用的就定义成私有（private:）。想要保护起来的就定义成（protect:）。

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

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

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

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

接下来做具体演示：

class默认private：

struct默认public：

public：

private：

此时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++中，这些艺术品就受到了保护，有工作人员的巡逻，有摄像头的抓拍，也有玻璃罩将其封装到安全范围内。

5、类的作用域

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

如下我们定义两个类（栈和队列）
//栈
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文件中

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

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

6、类的实例化

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

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

7、类对象模型

如何计算类对象的大小

现在给出这样一个类：
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）来看，类对象的存储方式采用的是第二种方式。

**为什么计算大小不考虑成员函数呢？**我们先来探讨下如若我调用两次相同的成员函数，那么这两个函数是一样的吗？答案是就是同一份函数，我们可以查看反汇编来验证：

通过反汇编得知，调用两次相同的Init()函数call的地址都是一样的，所以就没有必要把函数在对象里面存一份，因为调用的都是同一个函数，如果我每一个函数都存一个函数指针就浪费了。

相反成员变量必须得各自存一份，因为各个成员变量的值是不一样的，我函数是一样的可以不存，但是成员变量就不能不存了，所以我们就可以把函数放到公共代码区里了。也就是说我调用函数是在这个公共代码段里调用的。综上类大小的计算不考虑成员函数。

清楚了类的存储方式，来做几个题：
// 类中既有成员变量，又有成员函数
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

注意：当类里没有成员变量时，至少会给它开一个字节大小的空间，这1个字节不是为例存储有效数据，而是为了占位，表示对象存在过

结论：

没有成员变量的类对象，编译器会给它们分配1字节占位，表示对象存在过。
一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。

结构体内存对齐规则

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

【面试题】

结构体怎么对齐？为什么要进行内存对齐
如何让结构体按照指定的对齐参数进行对齐
什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景

8、this指针

this指针的引出

在之后的学习中，我们会学到日期类

class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;

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

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

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

this指针

this指针的引出

在之后的学习中，我们会学到日期类

class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;

[外链图片转存中…(img-TCGHLoMl-1715532044097)]
[外链图片转存中…(img-9RfcJNi4-1715532044098)]

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

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

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