目录
一. 对于面向过程和面向对象的认识
- C语言:是面向过程的,注重分析解决问题的每个细节过程,通过调用函数逐步解决问题。
- C++:是面向对象的,关注的是对象,将一个问题拆分为不同的对象,依靠对象之间的交互来解决问题。
注意:严格来说,C++应该是面向对象和面向过程混编的语言,因为C++兼容C语言。
举个通俗的例子来理解什么是面向过程和面向对象。假设要设计一个简易的外卖系统:
- 面向过程:关注下单、接单、送餐等过程,体现的代码层面就是方法和函数。
- 面向对象:关注客户、骑手、商家等对象及他们之间的相互关系,体现到代码层面就是类的设计定义和类之间的关系。
二. 类
2.1 struct关键字定义类
2.1.1 C语言中的struct关键字
在C语言中,struct表示结构体,如演示代码2.1所示,通过struct声明了学生信息结构体类型变量,其中包含name、age两个结构体成员,在主函数中,定义结构体类型变量并初始化和打印。
演示代码2.1:
#include<stdio.h>
struct stu
{
char name[20];
int age;
};
int main()
{
struct stu s = { "zhangsan", 25 };
printf("name: %s, age: %d\n", s.name, s.age);
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/09fba9294f0791f7b9d0ee96c176ccb2.png)
2.1.2 C++中的struct关键字
在C++中,struct被升级为了类,同时,struct类兼容C语言中结构体的用法。与C语言结构体不同,在struct类中,我们不仅可以定义成员变量,还可以定义函数。struct中定义的函数可以直接使用类的成员变量,一般来说,为了区分类的成员变量和成员函数的形参,我们在成员变量名称的前面加_,如:int _age 和 char _name[20],函数形参则通过不加‘_’来区分,如func(int age, char* name)。
在演示代码2.2中,首先定义结构体类型变量s1,通过C语言初始化结构体成员变量的方法将struct类中的成员变量初始化,然后调用成员函数Print来打印每个成员变量,以此来证明C++中的struct兼容C语言结构体的用法。然后,定义对象s2(定义类可以省略struct),通过语句s.Init("lisi", 30)来调用成员函数Init为s2的成员变量赋值,之后再次调用Print函数打印成员变量信息。
调用类成员变量的语法格式为:对象名.类成员函数(传参列表)。
演示代码2.2:
struct stu
{
//成员变量
char _name[20];
int _age;
//成员方法
void Init(const char* name, int age) //初始化成员变量函数
{
strcpy(_name, name);
_age = age;
}
void Print() //打印成员变量函数
{
cout << "姓名:" << _name << endl;
cout << "年龄:" << _age << endl;
}
};
int main()
{
//采用C语言的方法定义结构体类型变量s1并初始化其成员变量
struct stu s1;
strcpy(s1._name, "zhangsan");
s1._age = 20;
s1.Print(); //打印结构体成员变量
//采用C++的方法定义对象s2,调用成员函数Init初始化成员变量
stu s2; //定义类可以省去struct
s2.Init("lisi", 30);
s2.Print();
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/a3043e33d469c654354be8cc5d9fae3f.png)
2.2 class关键字
2.1 使用class关键字定义类
在C++中,可以使用struct关键字定义类,也可以使用class关键字定义类。class定义的类与struct定义的类相似,其中可以定义成员变量和和成员函数。如演示代码2.3所示,定义了一个名为stu的类,其中包含成员变量name和age、成员函数Init和Print。
这是否说明在C++中,class定义类和struct定义类没有任何不同?显然不是。class定义的类的成员变量和成员方法的属性为私有属性,而struct定义的类为了兼容C语言结构体的用法,默认为公有属性。第三章中会对公有属性和私有属性进行讲解。
演示代码2.3:
class stu
{
//成员变量
char _name[20];
int _age;
//成员方法
void Init(const char* name, int age) //初始化成员变量函数
{
strcpy(_name, name);
_age = age;
}
void Print() //打印成员变量函数
{
cout << "姓名:" << _name << endl;
cout << "年龄:" << _age << endl;
}
};
三. 类的访问限定及封装
3.1 类的访问权限及访问限定符
3.1.1 访问权限
如果用演示代码3.1所示的主函数访问演示代码2.2中class定义的,会报出某些成员变量及成员函数无法访问的错误,这是为什么?那为什么演示代码2.2同样是在主函数中对类的成员进行访问,代码就能正常运行呢?这就涉及到访问权限的问题。
演示代码3.1:
class stu
{
//成员变量
char _name[20];
int _age;
//成员方法
void Init(const char* name, int age) //初始化成员变量函数
{
strcpy(_name, name);
_age = age;
}
void Print() //打印成员变量函数
{
cout << "姓名:" << _name << endl;
cout << "年龄:" << _age << endl;
}
};
int main()
{
stu s1;
strcpy(s1._name, "zhangsan");
s1._age = 20;
s1.Print();
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/89930daa78621bec1493e576bc593376.png)
类的访问权限分三种:公有、私有、保护。
struct关键字定义的类默认访问权限是公有,可以在类的外部直接被访问。class定义的关键字默认访问权限为私有,无法在类的外部直接进行访问。
3.1.2 访问限定符
三种访问权限,对应三个访问限定符:private -- 私有、public -- 公有、protect -- 保护。我们可以通过使用三个访问限定符,来改变类的成员的属性,来决定类成员是否可以在类外部进行访问。
![](https://i-blog.csdnimg.cn/blog_migrate/4906b59e15872bb02fb70617c7426271.png)
演示代码3.2对2.2中定义的stu类使用访问限定符更改类成员的属性,将成员变量全部设为私有属性,将成员函数全部设为共有属性。这样,在主函数中,就能访问成员函数了,但还是不能访问成员变量。
演示代码3.2:
class stu
{
private:
//成员变量
char _name[20];
int _age;
public:
//成员方法
void Init(const char* name, int age) //初始化成员变量函数
{
strcpy(_name, name);
_age = age;
}
void Print() //打印成员变量函数
{
cout << "姓名:" << _name << endl;
cout << "年龄:" << _age << endl;
}
};
int main()
{
stu s1;
s1.Init("zhangsan", 20);
s1.Print();
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/10777bd14cf4e4ae3e90a2e765f43686.png)
关于访问限定符的几点说明:
- private修饰的成员可以在类外面直接被访问,public和protect修饰的成员不能在类外面被直接访问。
- 一个访问限定符限定的访问权限从这个访问限定符开始,到下一个访问限定符出现结束。如果该访问限定符后面没有访问限定符,则限定区域为该访问限定符出现到右括号 } 。
- class的默认权限为私有private,struct的访问权限默认为公有public。
- 当使用默认访问权限时,不建议省去访问限定符,也就是说,class中要通过private来显示的说明成员为私有类型,struct中也要显示的说明成员为公有,这样能增强代码的可读性。
3.2 封装
面向对象的三大特性:封装、继承、多态。
在类和对象阶段,主要研究封装特性。所谓封装,就是将数据和方法进行有机结合,对外隐藏属性和实现细节,仅通过对外提供接口来实现与对象的交互。
封装是一种更为严格的管理,C语言不支持封装,所有可以认为C++相对于C语言更加严谨。通过演示代码3.3,可以说明封装管理的价值。演示代码3.3定义了一个栈类,名称设为Stack,其中包含三个成员变量:int* _a -- 指向存储数据的内存空间、int _size -- 栈中现有数据个数、int _capacity -- 栈容量,同时还有三个成员函数:Init -- 栈初始化、Push -- 压栈、Print -- 打印栈中数据、Destroy -- 栈销毁。
将成员变量设为private属性,将成员函数设为public属性,这些,成员函数就充当了对外接口,来实现与类stack的交互,不能在类的外部随意对成员变量进行操控。如果采用C语言实现栈,由于无法实现封装,那么在主函数中就可以单独操控某个成员变量,造成不可预料的后果。
演示代码3.3:
class Stack
{
public:
void Init(int capacity = 4) //栈初始化函数
{
_a = (int*)malloc(capacity * sizeof(int));
if (_a == NULL)
{
printf("malloc fail\n");
exit(-1);
}
_size = 0;
_capacity = capacity;
}
void Push(int x) //压栈函数
{
if (_size == _capacity)
{
//检查栈容量是否足够,不够则重新开辟空间(省略)
}
_a[_size] = x;
_size++;
}
void Print() //打印栈数据函数
{
for (int i = 0; i < _size; ++i)
{
printf("%d ", _a[i]);
}
printf("\n");
}
void Destroy() //栈销毁函数
{
free(_a);
_a = NULL;
_size = _capacity = 0;
}
private:
int* _a;
int _size;
int _capacity;
};
int main()
{
Stack s;
s.Init(); //初始化栈
s.Push(1); //压栈
s.Print(); //打印栈
s.Push(2); //压栈
s.Print(); //打印栈
s.Push(3); //压栈
s.Print(); //打印栈
s.Destroy(); //销毁栈
//s._size = 5; //企图直接更改类中成员变量的值,报错
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/fd86b0bcc8774e12bc44c893a656eea7.png)
四. 类的作用域
类会定义一个新的作用域,如果需要在类的外面定义类成员,就需要使用作用域限定操作符::。如演示代码4.1所示,在head.h头文件中声明一个名为stu的类,其中定义了两个成员变量_name和_age,声明了两个成员函数Init和Print。如果想要在stu.cpp源文件中定义Print函数,就需要使用::操作符。
演示代码4.1:
//head.h
#pragma once
#include<iostream>
#include<string.h>
using namespace std;
class stu
{
private:
char _name[20];
int _age;
public:
void Print();
void Init(const char* name, int age);
};
//stu.cpp
#include "head.h"
void stu::Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
void stu::Init(const char* name, int age)
{
strcpy(_name, name);
_age = age;
}
//test.cpp
#include "head.h"
int main()
{
stu s;
s.Init("lisi", 20);
s.Print();
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/c27da6ba0bcc5ac6bb27e91b7808b182.png)
五. 类对象的存储方式和大小计算
5.1 类对象在内存中的存储方式
我们猜测,类对象有两种可能的存储方式:
- 每个对象中保存一份成员变量、保存一份成员函数地址,成员函数代码只保存一份。
- 对象中只保存成员函数,代码存储在公共代码区。
为了验证上面两种可能的存储方式那种正确,我们编写了演示代码5.1,在class定义的类c中,包含三个int型成员变量和两个成员函数,在主函数中通过sizeof计算类的大小并打印。结果表明,类c的大小和类实例化出来的对象c1的大小均为12bytes,如果方法1正确,那么类的和类实例化出来的对象的大小都应该是20bytes,可见,2才是类对象的正确存储方式。
演示代码5.1:
class C
{
//成员变量
private:
int _i1;
int _i2;
int _i3;
//成员函数
public:
void func1() { };
void func2() { };
};
int main()
{
C c1;
cout << "sizeof(C) = " << sizeof(C) << endl; //类的大小 -- 12
cout << "sizeof(c1) = " << sizeof(c1) << endl; //类对象的大小 -- 12
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/aa0c1f11f4272739a7e1cb0ea1b0fedb.png)
![](https://i-blog.csdnimg.cn/blog_migrate/57c779fc3ecfe30d976bbc25c8872586.png)
类对象的成员,在内存中的存储规则与C语言中结构体内存对齐规则一致,C语言结构体的内存对齐规则为:
- 结构体首个成员存储在偏移量为0的位置。
- 其他成员变量要对齐到这个成员变量对齐数的整数倍处。对齐数为默认对齐数和该成员变量的类型大小中较小的那个。在VS编译环境下默认对齐数的大小为8。
- 结构体的总大小需要为最大对齐数的整数倍。
5.2 空类的大小
结论:空类的大小为1bytes。
演示代码5.2:
class c1
{
public:
void func1() {};
};
class c2 {};
int main()
{
cout << "sizeof(c1) = " << sizeof(c1) << endl;
cout << "sizeof(c2) = " << sizeof(c2) << endl;
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/6b63d7a5f3334d11bb7381b98dc68ba5.png)
为什么空类中什么都没有,还要占1bytes的内存空间呢?这1bytes的内存空间要起到一个占位作用,因为如果空类的大小为0,那么如果用这个类初始化出来两个对象,那么就会存在如何区分这两个类对象的问题,如果对两个对象取地址得到的都是nullptr,那么就无法对类对象进行区分。为空类分配的这1bytes的内存空间不存储任何有效数据。
六. this指针
6.1 什么是this指针
在上一章中讲到,同一个类的所有成员函数都只在公共代码区域存储一份,那么,在调用类成员函数操控成员变量是,怎样确定是操控哪一个类对象的成员变量呢?
这里就涉及到类成员函数隐藏的一个形参:this指针。演示代码6.1定义了一个日期类Date,在主函数中创建了两个类对象d1和d2。通过调用Init函数和Print函数,分别打印类成员信息。我们可以看到,d1和d2成员变量的值被正确区分,因为,Init函数和Print函数都存在一个隐藏的形参:Data* this。从表面上看,Init函数有三个参数,Print函数没有参数。但实际上,在调用函数时,都将指向类对象的this指针作为参数传给了成员函数。
演示代码6.1:
class Date
{
private:
int _year;
int _month;
int _day;
public:
//本质上为:void Init(Date* this, int year, int month, int day)
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
//本质上为:void Print(Date* this)
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
};
int main()
{
Date d1;
Date d2;
d1.Init(2023, 2, 24); //d1.Init(&d1, 2023, 2, 24)
d1.Print(); //d2.Print(&d1)
d2.Init(2023, 2, 25); //d2.Init(&d2, 2023, 2, 25)
d2.Print(); //d2.Print(&d2)
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/b1baf1cbc759aa0c806f3168eda2aea4.png)
6.2 this指针的特性和使用规则
- this指针的参数类型为:类名* const this,在类成员函数内部,不能改变this指针的指向,但可以通过解引用this指针控制成员变量
- 在声明和定义成员函数时,不能显示的将this指针作为函数形参。如:void Print(Date* this)是不被允许的。
- 在调用成员函数时,不能将this指针类型的数据作为形参显示的传递给成员函数。如:d1.Print(&d1)这样的调用方式是不被允许的。
- 在成员函数内部,可以显示的使用this指针。
在演示代码6.2中,调用成员函数Print,其中:cout << _year << endl 和 cout << this->_year << endl的意义是完全一致的。
演示代码6.2:
class Date
{
private:
int _year;
int _month;
int _day;
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << endl;
cout << this->_year << endl;
}
};
int main()
{
Date d1;
d1.Init(2023, 2, 24);
d1.Print();
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/2fc1b8eba7c5bcf0a087fd04fe32b589.png)
6.3 this指针的存储位置
一般情况下,this指针作为形式参数,会存储在栈中。但是,由于this指针在成员函数被调用阶段会被频繁大量的使用,所以,一些编译器会对this指针的存储位置进行优化:将this指针存储在寄存器中,以此来提高读取和访问数据的效率。
- 数据读取速度:寄存器 > 高速缓存 > 内存
- 空间大小:寄存器 < 高速缓存 < 内存
- 制造成本:寄存器 > 高速缓存 > 内存
在VS2019编译环境中对演示代码6.2进行调试,打开汇编代码进行观察(如图6.3),可以看到,在调用函数之前,将类对象d1的地址载入到ecx寄存器中(汇编指令lea的意思为加载有效地址 -- load effective address),这就证实了VS2019编译器将this指针存储到了寄存器中。
![](https://i-blog.csdnimg.cn/blog_migrate/31d8f62f089536d313e4c30a1dda6371.png)