【C++】类和对象（上）

不良

已于 2023-06-19 10:39:19 修改

阅读量1.3k

点赞数 19

分类专栏： C++ 文章标签： c++ 算法开发语言

于 2023-05-28 10:24:02 首次发布

本文链接：https://blog.csdn.net/weixin_53943591/article/details/130909298

版权

C++ 专栏收录该内容

21 篇文章 2 订阅

订阅专栏

🚀 作者简介：一名在后端领域学习，并渴望能够学有所成的追梦人。
🚁 个人主页：不良
🔥 系列专栏：🚁C++ 🛸剑指 Offer
📕 学习格言：博观而约取，厚积而薄发
🌹 欢迎进来的小伙伴，如果小伙伴们在学习的过程中，发现有需要纠正的地方，烦请指正，希望能够与诸君一同成长！ 🌹

面向过程和面向对象初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

如我们平时洗衣服，按照面向过程的步骤即是：拿盆子 —>放水 —>放衣服 —>放洗衣粉 —>手搓 —>洗净拧干 —>晾衣服。

C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

而洗衣服如果是使用面向对象的方法：

总共有四个对象：人、衣服、洗衣粉、洗衣机
整个洗衣服的过程：人将衣服放进洗衣机、倒入洗衣粉、启动洗衣机，洗衣机就会完成洗衣过程并且甩干
整个过程主要是：人、衣服、洗衣粉、洗衣机四个对象之间交互完成的，人不需要关心洗衣机具体是如何洗衣服的，是如何甩干的。

类的引入

C++兼容C结构体的用法

struct ListNode {
	int val;
	struct ListNode* next;
    //c语言不支持在结构体里定义函数
    int func(int x, int y) //error
    {
        return x + y;
    }
};
int main()
{
    struct ListNode L1;//使用struct ListNode定义，因为C语言中struct ListNode要在一起才是类型名
    return 0;
}

在C语言中struct ListNode是类型，C语言中不支持在结构体里面定义函数；在C++中把结构体升级成了类，struct是声明类，在结构体里面不需要加struct，ListNode本身就是类型，同时在C++中还支持定义函数。

上面的代码我们在C++中可以这样写：

struct ListNode {
	int val;
	ListNode* next;
    
    //在C++中还支持定义函数
    int func(int x, int y)
    {
        return x + y;
    }
};
int main()
{
    ListNode L1;//在C++中ListNode就是类型
    return 0;
}

但是在C++中结构体的定义更喜欢用class来代替struct。

类的定义

class classname {

	//类体：由成员函数和成员变量组成

};//注意这里的分号

//命名空间这里没有分号，类这里有分号

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

类的两种定义方式：

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

class Date {
public:

	//声明和定义全部放在类里面
	void Print()
	{
		cout << _year << _month << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

声明放在头文件(.h)中，定义放在源文件(.cpp)中，需要注意：声明和定义分离，定义时成员函数名前需要加上类名和作用域限定符::，即加上classname ::。

//Date.h头文件
class Date {
public:

	//声明和定义分离
	void Print();
private:
	int _year;
	int _month;
	int _day;
};

//Date.cpp源文件

#include "Date.h"
void Date::Print()
{
	cout << _year << _month << _day << endl;
}

注意：当声明和定义分离时，不能同时出现缺省参数；只能在声明时使用缺省参数，如果同时使用缺省参数会报错。没有声明单独定义时也可以使用缺省参数

class Date {
public:

	//声明和定义分离
	void Print(int year = 2,int month = 3,int day = 4); //声明时使用缺省参数
private:
	int _year;
	int _month;
	int _day;
};

//Date.cpp源文件
void Date::Print(int year, int month, int day)
{
	cout << year << month << day << endl;
}

一般情况下，更期望采用声明和定义分离的方式。

成员变量命名规则的建议：在定义成员变量时，一般都是加个前缀或者后缀标识区分。

class Date{
	int _year;
	int _month;
	int _day;
};

类的访问限定符及封装

访问限定符

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

访问限定符：

public（公有）
protected（保护）
private（私有）

访问限定符说明：

public修饰的成员在类外可以直接被访问；

protected和private修饰的成员在类外不能直接被访问；

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

如果后面没有访问限定符，作用域就到 } 即类结束

class的默认访问权限为private，struct为public(因为struct要兼容C)

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

面试题：C++中struct和class的区别是什么？

C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。

封装

面向对象的三大特性：封装、继承和多态。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

在C++中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

类的作用域

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

class Date {
public:
	void Print();
private:
	int _year;
	int _month;
	int _day;
};
//这里需要指明Print属于Date这个类域
void Date::Print()
{
	cout << _year << _month << _day << endl;
}

类的实例化

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

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

就像C语言中定义了一个结构体一样，当你还未用该自定义类型创建变量时，定义结构体类型这个过程并没有分配实际的内存空间来存储它。所以类在未实例化之前仅仅只是声明，并没有分配实际的空间。

一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。

类是没有空间的，只有类实例化出的对象才有空间。如下：Date类是没有空间的，只有Date类实例化出的对象才有具体的日期。需要注意直接用实例化的对象调用成员变量要求成员变量是public的（公有的）。

int main()
{
	//Date._year = 2001;//error
	//Date._year = 11;//error
	//Date._year = 15;//error
	Date d1;
	d1._year = 2001;//true
	d1._month = 11;//true
	d1._day = 15;//true
}

做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图。

设计图只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

类对象模型

计算类对象的大小

#include<iostream>
using namespace std;
struct ListNode {
	int val;
	ListNode* next;
};
class List
{
public:
	void Init();
	void Push(int x);
	void Pop();
private:
	ListNode* head;
};
int main()
{
	List l1;
	l1.Init();
	l1.Push(1);
	l1.Push(2);
	
	List l2;
	l2.Init();
	l2.Push(1);

	cout << sizeof(l1) << endl;
	cout << sizeof(l2) << endl;
	return 0;
}

l1和l2的大小是否相同？

l1和l2是类实例化出来的对象，只是在栈上存储了指向堆里的指针，他们的大小相同。类本身是不占内存空间的，它在编译前是放在文件里，存在磁盘上的。编译后，变成指令存在公共代码段；类实例化出来的的对象才会占用内存空间。计算类型的大小就等同于计算类实例化出来的对象的大小。

类对象大小的计算和C语言结构体大小的计算一样，要考虑内存对齐。

类对象存储方式的猜测

对象中包含类的各个成员

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

那么针对上面的缺席如何解决呢？所以我们有了以下另外两种猜测：

代码只保存一份，在对象中保存存放代码的地址

只保存成员变量，成员函数存放在公共的代码段

对于上述几种猜测，我们可以根据下面的不同对象的大小进行判断：

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

类中没有成员变量的类的大小是1，这1byte不存储有效数据，作用是占位，标识对象被实例化定义出来了。

结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐以及注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

思考：为什么成员变量在对象中，成员函数不在对象中？

每个对象成员变量的内容是不一样的，需要独立存储；每个对象调用的成员函数是一样的，所以成员函数放到共享公共区域（代码段）。

结构体内存对齐规则

1.第一个成员在与结构体偏移量为0的地址处；

2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处；

注意：对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。VS中默认的对齐数为8

3.结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍；

4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

this指针

this指针的引出

我们先来定义一个日期类Date：

class Date
{
public:
	//初始化日期
	void Init(int year, int month, int day) 
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//打印日期
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1, d2; //实例化
	d1.Init(2023, 5, 27); //初始化
	d2.Init(2023, 5, 28);//初始化
	d1.Print(); //打印d1
	d2.Print();//打印d2
	return 0;
}

对于上述类，有这样的一个问题：
Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用Init函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？
C++中通过引入this指针解决该问题，即：C++编译器给每个非静态的成员函数增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

其实我们平时看到的形参列表和实参列表和编译器处理后的有所不同：

上图中，如果是d1调用，this就是d1的地址；如果是d2调用，this就是d2的地址。这是编译器处理的，在形参或者实参不允许自己加this指针，可以在类里面加直接转换成指令，我们可以利用下面的程序验证this指针的存在：

class Date
{
public:
	//初始化日期
	void Init(int year, int month, int day) 
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
	//打印日期
	void Print()
	{
		cout <<this-> _year << "/" << this->_month << "/" << this->_day << endl;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1, d2;
	d1.Init(2023, 5, 27);
	d2.Init(2023, 5, 28);
	d1.Print();
	d2.Print();
	return 0;
}

this指针的特性

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

我们通过下面这段代码更好的认识this指针：

#include <iostream>
using namespace std;
class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
	void Display()
	{
		cout << "Display()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* pa = nullptr;
	//pa->Display();       //代码1
	//pa->PrintA();     //代码2
}

当程序分别运行代码1和代码2时，程序运行的结果如何？是编译报错还是运行崩溃亦或正常运行？

我们可能看到指针p是一个空指针，而代码1和代码2都通过操作符->，间接性的执行了对p的解引用操作，所以我们可能认为程序会崩溃。其实不然，当程序执行代码1时，程序不会崩溃，会正常输出Display()；当程序执行代码2时，程序才会因为对空指针解引用而崩溃。

指针p是一个类的空指针，当执行代码1时，pa传给Display()函数中的this指针，但是成员函数中并没有对空指针p进行解引用，Display()等成员函数地址并没有存到对象里面，成员函数的地址是存在公共代码段的，所以不用解引用就可以直接打印Display()。

当程序执行代码2时，会因为对空指针解引用而崩溃。执行代码2时，调用了成员函数PrintA，成员函数的地址是存在公共代码段的，所以不用解引用，但是PrintA函数中要打印成员变量_a，成员变量_a只有通过对this指针进行解引用才能访问到，而this指针此时接收的pa是nullptr，对空指针解引用必然会导致程序的崩溃。