开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> C++【类和对象】【上篇】 -> 正文阅读

[C++知识库]C++【类和对象】【上篇】

我们上节初步认识了C++，那么本节就继续深入学习C++的内容

前言

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

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
在这里插入图片描述
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

一、类的引入

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

我们先来看看C++中的struct：
1、C++中struct支持所有C语言struct的用法
2、C++中的struct升级成为了类

下面是C++用struct实现的栈：

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;
}

与C的区别是：
C语言struct里面只有属性，没有方法；但是C++里面既有属性，又有方法

C++里面方法可以认为就是函数

上面C++栈的使用：

int main()
{
	Stack s;
	s.Init(10);
	s.Push(1);
	s.Push(2);
	s.Push(3);
	cout << s.Top() << endl;
	s.Destroy();
	
	// 兼容C语言中对结构体的用法
	Q q1;
	struct Queue q2;
	QueueInit(&q1);

	// C++的方法，把Queue当成类
	Queue q3;


	return 0;
}

二、类的定义

模板：

class className

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

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

C++中具体定义栈：
里面的private、public我们下面就会讲

struct Stack
class Stack
{
private:
	int* a;
	int top;
	int capacity;

public:
	void Init(int N = 4)
	{
		// ...
		top = 0;
		capacity = 0;
	}

	void Push(int x)
	{
		//...
	}

};

int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	st.Push(3);
	st.Push(4);

	// error C2248: “Stack::top”: 无法访问 private 成员(在“Stack”类中声明)
	// st.top;


	return 0;
}

//
class Stack // 类型
{
public:
	void Push(int x)
	{
		// Init();
		//...
	}

	void Init(int N = 4)
	{
		// ...
		top = 0;
		capacity = 0;
	}

private:
	int* a;  // 声明   没有空间，不能直接stack：：a来访问
	int top;
	int capacity;
};

struct Stack_C // 类型
{
	int* a;    // 声明   没有开空间
	int top;
	int capacity;
};

int main()
{
	//Stack::a = 0;//不能这样访问a，a只有声明，没有定义，不开辟a的空间
	//Stack_C::a = 0;//这里不行

	//Stack st;
	//st.a = 0;//这里可以访问，因为有了st，但是a受访问限定符限制了

	return 0;
}

C++中成员变量和成员函数可以随便定义在哪一个位置，甚至可以交叉定义，但最好不要这样，要么成员函数全部在成员变量上面，要么全部在下面

C语言中，定义的变量和函数没有必然关联，所以当我们要使用一个函数或者变量的时候，前面要有函数或者变量的声明或者定义，因为C语言为了效率只会向上搜索，不会向下搜索
C++中，类里面的数据都是一体的，所以搜索的时候不分上下，直接在整个类里面搜索

类的两种定义方式

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

在这里插入图片描述

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

在这里插入图片描述
我们一般采用第二种方法，因为第二种方法更方便别人的阅读调用函数接口

举例：
1.h
声明和定义分离是为了让其他人更方便看懂我们的代码

#pragma once

//inline int func1();

// 声明和定义分离

class Stack // 类型
{
public:
	void Push(int x);
	void Init(int N = 4);
private:
	int* a;  // 声明
	int top;
	int capacity;
};

class Queue // 类型
{
public:
	void Init();
	void Push(int x);
private:
	//...
};

1.cpp

#include"1.h"
void Stack::Push(int x)
{
	//...
}

void Stack::Init(int N)
{
	top = 0;
	capacity = 0;
}

void Queue::Init()
{

}

void Queue::Push(int x)
{
	//...
}

test.cpp

#include"1.h"
int main()
{
	Stack st;
	Queue qr;
	return 0;
}

类的命名规则

// 我们看看这个函数，是不是很僵硬？

class Date
{
public:
 	void Init(int year)
 	{
 		// 这里的year到底是成员变量，还是函数形参？
 		year = year;
 	}
private:
 	int year;
};

// 所以一般都建议这样
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、访问限定符

C++实现封装的方式：

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

在这里插入图片描述

知识点(重要)

【访问限定符说明】

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

注意：
1、访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别
2、访问限定符在类里面是无效的，不受限制的

面试题：
问题：C++中struct和class的区别是什么？
解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来
定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类
默认访问权限是private。
注意：在继承和模板参数列表位置，struct和class也有区别，后序给大家介绍。

2、封装

【面试题】

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

这里面向对象的特性不止这三种，还有抽象、java里面的反射…
而这上面的大三特性是面向对象中最出名的。类似于中国的四大名著和五岳一样

在类和对象阶段，主要是研究类的封装特性，那什么是封装呢？

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

我来进一步观察封装的作用

举例：实现一个栈

C语言中，实现一个栈我们可以既访问方法（这里的方法指接口函数），又可以访问数据（这里的数据是指结构体内部的成员变量）
在这里插入图片描述
大家看，如果我们需要提取栈顶元素：
在C语言里面，我们不仅可以通过调用StackTop这个函数接口来提取；
还可以通过直接使用结构体里面的成员变量top来提取：

Stack st;
st.a[st.top];

这个时候就出问题了。因为如果我的初始化capacity为-1的话，那么st.a[st.top];可以提取到我们需要的值；
但是，如果我的初始化capacity为0的话，我们提取到的值是一个随机值
甚至有的人会直接修改你的结构体成员变量

所以，C语言中这种太自由的方法存在一些不好的地方。那么，在C++在C的基础上进行了改进，实施了封装
在这里插入图片描述

在C++中，我们可以把方法（函数）设置为公开的；数据（成员变量）设置为私有的。这样，我们对栈的增删查改就只能调用公有成员来实现，不会出现上面C语言的那种情况（简而言之就是，你类外面的操作想要对栈进行增删查改，就必须按照我类里面的规定来，哪些是公开可用的，哪些是私有不可用的）

封装本质上是一种管理，让用户更方便使用类。
在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

3、类的作用域

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

举例：

class Person
{
public:
 	void PrintPersonInfo();
private:
 	char _name[20];
 	char _gender[3];
 	int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
 	cout << _name << " "<< _gender << " " << _age << endl;
}

那么就有人会问了
在这里插入图片描述
为什么这里使用域作用限定符会报错？
首先，我们来分析为什么不能Person::_age=1；

因为_age在Person中只是一个声明，它不是定义实现。所以，_age不会开辟空间，我们并不能访问这个_age并且赋值

而Person::PrintPersonInfo();不能这样的原因我们下面会讲，它不能这样使用与我们下面的this指针有关

四、类的实例化

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

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

比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。

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

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

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

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

在这里插入图片描述

五、类对象模型

1、如何计算类对象的大小

class Person
{
public:
	void PrintPersonInfo()
	{}
	int qwe;
};
int main()
{
	Person at;
	cout << sizeof(at) << endl;//这里sizeof计算类名，与计算类的对象结果是一样的，都是类对象的大小
	cout << sizeof(Person) << endl;
	return 0;
}

问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？

在这里插入图片描述

可以看到类对象占用了4个字节，也就是说：

类对象里面只有成员变量，没有成员函数，所以上面的at只占4个字节的原因就是at里面只有qwe这个成员变量，没有PrintPersonInfo()这个函数

至于为什么类中不包含成员函数，就要看看下面的C++类对象的存储设计方案了

2、类对象的存储方式

A、方式1

·对象中包含类的各个成员

在这里插入图片描述
但是方式1缺陷很明显，举个例子：

class Person
{
public:
	void Print()
	{}
	int q;
};
int main()
{
	Person a1;  Person a2;
	a1.q = 1;   
	a2.q = 2;
	a1.Print(); 
	a2.Print(); 
	return 0;
}

在这里插入图片描述
可以看到，上面C++代码的汇编指令里面，a1和a2的q是不同的数据；
但是a1和a2都调用了相同的函数Print,因为两个函数的汇编指令call的地址一模一样。
所以，方式1把成员函数也放到对象里面太浪费空间了，因为多个对象调用的都是相同的函数

缺陷：

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

B、方式2

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

在这里插入图片描述
方式2就是说：

把成员变量放到对象里面，让成员函数汇集成一个表，再把这个表放到公共代码区（常量区）；最终在对象中存储一个地址，这个地址可以在公共代码区中找到成员函数表

C、方式3

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

在这里插入图片描述

这个就是在2的基础上，再次改进，直接舍弃掉函数表的地址

结论

通过上面三种方式，以及方式1的举例，我们可以先一步排除方式1，太浪费空间了；
那么2和3谁更好呢？我们采用的是方式3

这是因为，既然我不管需不需要函数表的地址，这个函数表都是放在公共代码区的，那我为什么要多此一举记录这个地址呢？
直接让编译器在对象调用函数的时候，自动去找我们要调用的函数不好吗？反正编译器知道这些函数都是存放在公共代码区的，很容易找到

所以，方式2可行，但没必要；还是方式3更胜一筹

例题

// 类中仅有成员函数

class A2 {
public:
   void f2() {}
};

// 类中什么都没有---空类
class A3
{};

上面两个类对象的大小是多少呢？是不是有人认为是0字节呢？我们来看看答案
在这里插入图片描述

答案是1

解析：

空类和只有函数成员的类我们要给一个占位，这个占位不存储有效数据，只标识对象存在

也就是为了防止对类的对象的取地址失败：

小结

1、一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐
2、注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象
3、类内部的函数是编译好指令之后才存放在公共代码区的

3、结构体内存对齐

结构体内存对齐规则：（重要）

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

【面试题】

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

这些面试题我就不讲了，以前C语言博客里面有答案，不会的话大家就要回去复习C语言了😣😣😣

六、this指针

1、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, d2;
 	d1.Init(2022,1,11);
 	d2.Init(2022,1,12);
 	d1.Print();
 	d2.Print();
 	return 0;
}

在这里插入图片描述
对于上述类，有这样的一个问题：
凭什么你d1初始化之后是2022-1-11，而d2初始化之后是2022-1-12；怎么d1不是12，d2不是11呢？

对此，C++提出来了this指针：

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

什么意思呢？
就是说：

对象在调用函数的时候，函数的参数部分有一个隐藏的形参this指针。这个指针是所有成员函数的第一个形参，只不过是隐藏的，我们看不到。
而d1.Print()因为函数不在对象内部，所以d1不会在内部查找Print函数，而是转换成了：Print(&d1)。d2.Print()同理转换成了Print(&d2)，那么this指针就是用来接收调用函数对象的地址

所以，每个成员函数的调用，都隐藏着调用函数对象的地址。这样就是谁（某个对象）调用函数，就把谁（该对象）的地址传给this，那么函数进行访问等一系列操作的，就是谁（该对象内部）的成员变量

回到上面的问题：为什么不能用类名+域作用限定符来访问成员函数？
答案：因为成员函数隐藏着this指针，如果使用该方法，就没有地址传给this，那么函数内部的成员变量就无法确定是谁（哪一个对象）的内部成员变量

2、this指针的特性

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

this指针原型：

类名*const this

const修饰this指针本身，使得this无法被赋值
在这里插入图片描述

面试题

this指针存在哪里？

this指针是形参，一般存储在栈帧上面。但是有些编译器（比如vs）对this指针进行了优化，把this指针放在寄存器（ECX）中，用来提高效率

this指针可以为空吗？

this指针可以为空，但是有条件，当我们进行操作时不需要this指针去指向某个对象（比如打印一个东西）的时候就可以为空

题目：

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行

class A
{
public:
 	void Print()
 	{
 		cout << "Print()" << endl;
 	}
private:
 	int _a;
};
int main()
{
 	A* p = nullptr;
 	p->Print();
 	return 0;
}

// 2.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{ 
public:
    void PrintA() 
    {
        cout<<_a<<endl;
    }
private:
 	int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
}

答案是C和B：

右图中this是P的地址，而P是空，所以this也是空，找a解引用就产生了空指针解引用

补充：空指针是运行错误，编译检查不出来

C语言和C++实现Stack的对比

C语言实现

typedef int DataType;
typedef struct Stack
{
 	DataType* array;
 	int capacity;
 	int size;
}Stack;
void StackInit(Stack* ps)
{
 	assert(ps);
 	ps->array = (DataType*)malloc(sizeof(DataType) * 3);
 	if (NULL == ps->array)
 	{
 		assert(0);
 		return;
 	}
 	ps->capacity = 3;
 ps->size = 0;
}
void StackDestroy(Stack* ps)
{
 	assert(ps);
 	if (ps->array)
 	{
 		free(ps->array);
 		ps->array = NULL;
 		ps->capacity = 0;
 		ps->size = 0;
 	}
}

void CheckCapacity(Stack* ps)
{
 	if (ps->size == ps->capacity)
 	{
 		int newcapacity = ps->capacity * 2;
 		DataType* temp = (DataType*)realloc(ps->array, 
		newcapacity*sizeof(DataType));
 		if (temp == NULL)
 		{
 			perror("realloc申请空间失败!!!");
 			return;
 		}
 		ps->array = temp;
 		ps->capacity = newcapacity;
 	}
}
void StackPush(Stack* ps, DataType data)
{
 	assert(ps);
 	CheckCapacity(ps);
 	ps->array[ps->size] = data;
 	ps->size++;
}
int StackEmpty(Stack* ps)
{
 	assert(ps);
 	return 0 == ps->size;
}

void StackPop(Stack* ps)
{
 	if (StackEmpty(ps))
 	return;
 	ps->size--;
}
DataType StackTop(Stack* ps)
{
 	assert(!StackEmpty(ps));
 	return ps->array[ps->size - 1];
 }
int StackSize(Stack* ps)
{
 	assert(ps);
 	return ps->size;
}
int main()
{
 	Stack s;
 	StackInit(&s);
 	StackPush(&s, 1);
 	StackPush(&s, 2);
 	StackPush(&s, 3);
 	StackPush(&s, 4);
 	printf("%d\n", StackTop(&s));
 	printf("%d\n", StackSize(&s));
 	StackPop(&s);
 	StackPop(&s);
 	printf("%d\n", StackTop(&s));
 	printf("%d\n", StackSize(&s));
 	StackDestroy(&s);
 	return 0;
}

可以看到，在用C语言实现时，Stack相关操作函数有以下共性：

·每个函数的第一个参数都是Stack*
·函数中必须要对第一个参数检测，因为该参数可能会为NULL
·函数中都是通过Stack*参数操作栈的
·调用时必须传递Stack结构体变量的地址

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据
的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出
错。

C++实现

typedef int DataType;
class Stack
{
public:
 	void Init()
 	{
 		_array = (DataType*)malloc(sizeof(DataType) * 3);
 		if (NULL == _array)
 	{
 	perror("malloc申请空间失败!!!");
 	return;
 	}
	_capacity = 3;
 	_size = 0;
 } 
 void Push(DataType data)
 {
 	CheckCapacity();
 	_array[_size] = data;
 	_size++;
 }
 void Pop()
 {
 	if (Empty())
 	return;
 	_size--;
 }
 DataType Top(){ return _array[_size - 1];}
 int Empty() { return 0 == _size;}
 int Size(){ return _size;}
 void Destroy()
 {
 	if (_array)
 	{
 		free(_array);
 		_array = NULL;
 		_capacity = 0;
 		_size = 0;
 	}
 }
private:
 void CheckCapacity()
 {
 	if (_size == _capacity)
 	{
 		int newcapacity = _capacity * 2;
 		DataType* temp = (DataType*)realloc(_array, newcapacity * 
 		sizeof(DataType));
 		if (temp == NULL)
 		{
 			perror("realloc申请空间失败!!!");
 			return;
 		}
 		_array = temp;
 		_capacity = newcapacity;
 	}
 }
private:
 	DataType* _array;
 	int _capacity;
 	int _size;
};
int main()
{
 	Stack s;
 	s.Init();
 	s.Push(1);
 	s.Push(2);
 	s.Push(3);
 	s.Push(4);
 	printf("%d\n", s.Top());
 	printf("%d\n", s.Size());
 	s.Pop();
 	s.Pop();
 	printf("%d\n", s.Top());
 	printf("%d\n", s.Size());
 	s.Destroy();
 	return 
 }

C++中通过类可以将数据以及操作数据的方法进行完美结合，通过访问权限可以控制那些方法在
类外可以被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。
而且每个方法不需要传递Stack*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack *
参数是编译器维护的，C语言中需用用户自己维护。