【C++】类和对象

最新推荐文章于 2024-07-22 23:59:01 发布

J.呵呵

最新推荐文章于 2024-07-22 23:59:01 发布

阅读量859

点赞数 15

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

本文链接：https://blog.csdn.net/2301_77112794/article/details/139214592

版权

C++ 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

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

在前面学习C语言的过程中，我们都知道C语言是一门面向过程的程序设计语言，前面初识C++我们又提到这是一门面向对象的程序设计语言那究竟什么是面向过程，什么又是面向对象。我们举个例子便可知道：
我们正常手洗衣服时，需要的步骤有：拿盆->放水->放洗衣粉->放衣服->手搓……简单的一个洗衣服，如果面向过程就是一步步去完成，较为繁琐。
但如果是面向对象，那么可以简化为：人将衣服放入洗衣机，倒入洗衣粉，启动洗衣机，洗衣机就会完成整个洗衣服的工作。
这里面则出现了四个对象：人、衣服、洗衣粉、洗衣机。
也就是整个洗衣过程是由这四个对象参与进来交互完成的，人不需要关注洗衣机到底怎么洗干净衣服的。
总结来说，C++是基于面向对象的，关注的是对象，一件事情会有哪些对象参与进来，靠对象之间的交互完成。

类的引入

前面我们有学习过C语言的结构体，它属于一种自定义类型，且它只能定义变量。而在C++中，结构体既可以定义变量，也可以定义函数，例如：
在C语言中定义：

struct Student
{
	int nums;//学号
	char name[20];//姓名
	char sex;//性别
};
void Set_infor();//输入信息函数
void Print_infor();//输出信息函数

而在C++中就可以把函数一起放入struct中，如：

struct Student
{
    void Set_infor();//输入信息函数
    void Print_infor();//输出信息函数
	int nums;
	char name[20];
	char sex;
};

也就是，C++升级struct将其升级成了类，但是C++中更喜欢用class来定义类。

类的定义

class className
{
    //类体：由成员函数和成员变量组成
}; // 分号必不可少

class：定义类的一个关键字
className：类的名字
{}：里面包含类的主体
;：类后面的分号不能省略，就像结构体一样。
类体中的内容称为类的成员：

类中的变量称为类的属性或成员变量
类中的函数称为类的方法或者成员函数

类的两种定义方式

声明和定义全部放在类体中，需要注意的是，成员函数如果在类中定义，会被当成内联函数处理。
如：

class Student
{
public:
    void Print_infor()//输出信息
	{
	    cout << nums << "-" << name << "-" << sex << endl;
	}//声明和定义全部放在类体中
    int nums;
	char name[20];
	char sex;
}

类声明放在.h文件中，成员函数放在.cpp文件中，此时在函数定义时要在函数名前面加上类名::
如：

//Student.h
class Student
{
public:
    void Print_infor();//输出信息
    int nums;
	char name[20];
	char sex;
}

//Student.cpp
#include"Student.h"
void Student::Print_infor()//输出信息
{
	cout << nums << "-" << name << "-" << sex << endl;
}//声明和定义分开

这里还是推荐大家将成员函数的声明和定义分开。
成员变量命名规则的建议：
我们写一个日期类：

class Date
{
public:
	void Init(int year)
	{
		year = year;
	}
private:
	int year;
};

这样写我们可能会分不清year到底是成员变量还是函数形参，
所以建议在成员变量前面加_，或者其它前缀或者后缀以便区分。
如：

class Date
{
public:
	void Init(int year)
	{
		_year = year;
	}
private:
	int _year;
};

类的访问限定符及封装

在前面的代码中，我们不免有些疑惑，代码中的public和private到底是什么意思呢，它们的作用又是什么，下面我们来一探究竟。
我们在类中定义了很多成员，包括成员函数和成员变量，但有时候我并不想让外界去访问或者修改我的一些成员，比如我不想让成员变量被修改，此时我们就要用到作用域限定符。
访问限定符有三个：

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

目前，我们常用的是，公有和私有这两个限定符，protected也会在后面讲到它的用法。
访问限定符的一些说明和注意事项：

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

那么什么是封装呢
面向对象公有三大特性：封装，继承，多态。
用规范的术语就是：封装是将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装本质上是一种管理，让用户更方便地使用类。
在C++中实现封装，可以通过类将数据以及操作数的方法有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法在类外可以直接被使用。
简单来说，C++的封装使得管理更加规范，把变量，函数都放在类里面，可以访问的放到公有，不能访问的放到私有。

类的作用域

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

class Student
{
public://外界可以访问的放公有
    void Print_infor();//输出信息
private://不想被外界访问或修改的放私有
    int nums;
	char name[20];
	char sex;
}
void Student::Print_infor()//在类外定义函数需要加上作用域限定符
{
	cout << nums << "-" << name << "-" << sex << endl;
}

类的实例化

用类类型创建对象的过程，称为类的实例化。定义出的类并没有分配实际的内存空间来存储它。
类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。
一个类可以实例化出多个对象，实例化出的对象是会占用实际的物理空间，来存储成员变量。
打个比方，类实例化出对象就像是现实中使用建筑设计图建造出房子，类就像是设计图，只是设计了一个房子，但并没有实体建筑的存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

类的对象大小的计算

我们前面写的类，既包含了成员变量又包含了成员函数，那我们要如何计算一个类的大小，是要将成员变量和成员函数的的内存大小一起计算吗，下面就来验证探讨一下。
上面我们说到，C++是将结构体升级成了类，但本质上还是结构体，因此类的成员变量的存储方式是和结构体中存储方式一样的，需要遵守内存对齐规则。
我们要纠结的是成员函数是否在类定义的对象中存储。
用类定义对象时，系统会为每个对象分配存储空间。如果用一个类定义了10个对象，那么是否要为每一个对象的数据和函数代码分别存储分配单元，并将其封装在一起呢，如下图所示：
在这里插入图片描述
而事实上并不是这样的，同一类的不同对象的数据成员的值一般是不一样的，但不同对象的函数的代码是相同的，不论调用哪一个的函数的代码，其实调用的都是相同内容的代码，这样在C++中，就存在了一个公共代码区，存放成员函数的代码，在调用各对象的函数时，都会去调用这个公共的函数代码，如下图所示：
在这里插入图片描述
我们同样可以通过代码来验证：

class Time
{
public:
	void set()
	{
		cin >> _hour >> _minute >> _sec;
	}
private:
	int _hour;
	int _minute;
	int _sec;
};
int main()
{
	cout << sizeof(Time) << endl;
	return 0;
}

结果如下：
在这里插入图片描述
我们发现Time类对象的大小就是12字节，也就是三个整型的大小，与成员函数无关，也就是函数的目标代码段时在对象空间之外的。
我们可以再来判断以下这几个类对象的所占用的字节大小是多少。

//类中既有成员函数又有成员变量
class A1
{
public:
	void f1(){}
private:
	int _a;
};
//类中只有成员函数
class A2
{
public:
	void f2() {}
};
//空类
class A3{};
int main()
{
	cout << sizeof(A1) << endl;
	cout << sizeof(A2) << endl;
	cout << sizeof(A3) << endl;
	return 0;
}

结果如下：
在这里插入图片描述
总结如下：
一个类的大小，实际就是该类中成员变量之和，同样要和结构体一样保持内存对齐，同时要注意空类的大小是1，这一个字节不存在有效数据，只是为了标识这个对象被类定义出来了。
拓展：
结构体内存对齐规则：

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

类成员函数的this指针

我们先来写一个日期类：

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;
	Date d2;
	d1.Init(2024,5,26);
	d2.Init(2024, 5, 27);
	d1.Print();
	d2.Print();
	return 0;
}

结果如下：
在这里插入图片描述
我们发现，Date类定义了两个对象，两个对象调用的都是同一个函数，但是结果却不同。
这样就产生了一个问题：Date类中有Init和Print两个成员函数，函数体中没有关于不同对象的区分，那当d1调用Init函数时，该函数是如何知道要设置d1对象，而不是d2对象呢？
在C++中，每一个成员函数中都包含一个特殊的指针，这个指针是固定的，称为this。它是指向本类对象的指针，它的值是当前被调用的成员函数所在的对象的起始地址。只不过所有操作对用户都是透明的，即用户不需要传递，编译器自动完成。
如图所示：
在这里插入图片描述

我们发现，如果显示使用this指针，编译器会报错，因此这个隐含的this指针，在实参和形参的位置都不能显示写出来，只能编译器自己加上，但是在成员函数内部可以使用。
总结来说，this指针有以下特性：