1.面向过程和面向对象初步认识
C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。
比如洗衣服的过程:C语言就是需要关注过程
C++是基于面向对象的,关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完成
2.类的引入
举例对比C语言和CPP的链表节点结构体的写法
// C语言的写法
struct ListNode_C
{
struct ListNode_C* next; // 变量类型:struct ListNode_C*
int val;
};
// C++的写法
struct ListNode_CPP
{
ListNode_CPP* next;// 变量类型:直接写类的名字就好:ListNode_CPP*
int val;
};
类中的成员函数(不用写某些参数) 可以直接 使用类中的成员变量,不像 C语言的函数(一个函数要接收多个参数)
// C++的类
struct Stack
{
// 成员函数
// 这类里面,定义的东西可以直接访问:对数组直接进行初始化
void Init(int n = 3)
{
array = (int*)malloc(sizeof(int) * n);
if (array = NULL) {
perror("malloc fail !");
return;
}
capacity = n;
top = 0;
}
// 成员变量
int* array;
size_t capacity;
size_t top;
};
int main()
{
struct Stack st1; // C语言的结构体用法(C++兼容C)
Stack st2; // 类的名称可以直接用
return 0;
}
上面结构体的定义,在C++中更喜欢用class来代替。
直接就把 struct 换成 class,其他的不用变,类的作用与含义不会变
因为 struct 就是C++为了兼容C语言所规定的语法
class Stack
{
// 成员函数
void Init(int n = 3)
{
array = (int*)malloc(sizeof(int) * n);
if (array = NULL) {
perror("malloc fail !");
return;
}
capacity = n;
top = 0;
}
void Push(int x = 0)
{
// ......
}
// 成员变量
int* array;
size_t capacity;
size_t top;
};
3.类 class 的定义
class className
{
// 类体:由成员函数和成员变量组成
}; // 一定要注意后面的分号:这里和 struct 是一致的
class 为定义类的关键字,ClassName为类的名字,{}中为类的主体,注意类定义结束时后面分号不能省略。
类体中内容称为类的成员:类中的变量称为类的属性或成员变量; 类的函数称为类的方法或者 成员函数。
3.1 类的两种定义方式:
3.1.1 声明和定义不分离
声明和定义全部放在类体中
需注意:成员函数如果在类中定义,编译器可能会将其当成内联函数处理(什么是内联函数?后续章节会讲解)
3.1.2 声明和定义 分离
类声明放在.h文件中,成员函数定义放在.cpp文件中,注意:成员函数名前需要加类名::
我们更推荐 声明和定义 分离
4. 类的访问限定符及封装
这里报错:不可访问
上面那个报错实际上是因为 在 类的外面,不能直接访问类里面的东西
这就引出 :访问限定的概念
4.1 访问限定符
4.1.1 C++实现封装的方式:
设计一个类:用类将对象的属性与方法结合在一块,让对象更加完善,
访问权限的设置:通过访问权限选择性的将其接口提供给外部的用户使用。
(即 一个类中,你可以设置哪些东西可以给外界使用,哪些东西不可以给外界使用)
4.1.2 访问限定符的分类
4.1.3 访问限定符说明
1、public 修饰的成员在类外可以直接被访问
2、protected 和 private 修饰的成员在类外不能直接被访问 (此处protected和private是类似的)
那如何将私有的变成公有,改变访问限定?:使用访问限定符 public
3、class 的默认访问权限为 private(在类外不能直接访问),struct 默认为 public (因为struct要兼容C,C里面没有访问限定的定义,干脆直接“开放成公有制”)
这段代码:在类的外面访问类,可以发现,class 形式的类报错(不可访问),struct 可以访问
具体代码如下:
class Stack_1 // class 形式的类
{
void Init1()
{
// ....
}
};
struct Stack_2 // 结构体 struct形式的类
{
void Init2()
{
// ....
}
};
int main()
{
// class 形式的类
Stack_1 st1;
st1.Init1(); // 报错
// 结构体 struct形式的类
struct Stack_2 st2;
st2.Init2(); // 不报错
return 0;
}
4.1.4 访问权限作用域 大小
(1)从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
示例如下:从一个 public 开始到下一个 public 框定的范围 就是 访问权限作用域
这样可以发现,class 的类可以直接在 类的外面访问 函数Init ,因为这个函数属于 public 的公有访问权限作用域
(2)如果后面没有访问限定符,作用域就到 } 即类结束。
(3)通常情况下,(这样比较规范但非必须)在类中,把成员函数设置成公有:public,将成员变量设置为私有:private
为什么一般是将成员函数设置成公有,将成员变量设置为私有?
答:使外界只能使用公开的函数(已设计好的),“强制”你使用规范的行为
举个例子:像我们这个 栈的类,有个 top 变量,代表栈顶:a[top-1] 这个就是栈顶元素,但是总有人会搞出数组越界的操作:a[top]
这个操作的本质是直接使用到了 top 这个成员变量,所以我们将 top 这类的成员变量设置成私有的,就是不想让你随便的操作到成员变量,而只能通过设计的成员函数来执行一些功能
你想获取到栈顶元素,就只能通过 成员函数Top(),不能直接使用成员变量 top:a[top-1] ,在达成目的的同时,也不会出现 a[top] 这类的错误操作
class Stack // class 形式的类
{
public:
int Top(){
return a[top - 1];
}
private:
int* a;
int top;
};
int main()
{
// class 形式的类
Stack st;
int tmp = st.Top();
cout << tmp << '\n';
return 0;
}
通过这个类的封装可以反映出 C++ 使得代码相较于 C语言更加规范化,减少了许多非规范化的行为程序的产生
规范化使得程序设计有次序的进行
注意:访问限定符只在编译时有用,当数据映射到内存后,没有任何访问限定符上的区别
就是在语义上限制你的行为
4.2【面试题】C++中 struct 和 class 的区别是什么?
解答:
C++需要兼容C语言,所以 C++ 中 struct 可以当成结构体使用。
另外 C++ 中 struct 还可以用来 定义类。和 class 定义类是一样的,区别是 struct 定义的类默认访问权限是 public,class 定义的类 默认访问权限是 private。
注意:在继承和模板参数列表位置,struct和 class 也有区别,后续给大家介绍。
5. 成员变量的书写规范
平时我们看到 C++ 类 的源码可以发现:类里面的成员变量都清一色的在名字前面加一个下划线
原因:
举个例子演示,便于解释原因
运行下面这段代码:我们想要初始化类里面的日期成员变量为 2024/5/1,但是运行之后可以发现成员变量 year / month / day (不是指Init函数的)这三个变量根本就没有改变,初始化失败
本意是想要初始化成员变量 year / month / day ,但是函数里面 year = year; 这样表示自己赋值给自己,而不是使用传递过来的参数 (int year, int month, int day),为了方便识别以及不用修改 传参(这样的可读性好),我们通常就会在 成员变量 前面加一个下划线
class Time // 日期类
{
public:
void Init(int year, int month, int day)
{
year = year;
month = month;
day = day;
}
private:
int year;
int month;
int day;
};
int main()
{
Time t;
t.Init(2024, 5, 1);
return 0;
}
修改后:不是一定要求在前面加一个下划线,也可以在后面加,写可以写成 m_year (m 代表 member)
主要是为了区分而已
class Time // 日期类
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
注意:也可以使用 this指针(本文的后面章节有讲解)
成员变量可以写成同名的,但使用时需要使用 this 指针
class Time // 日期类
{
public:
void Init(int year, int month, int day)
{
this->year = year;
this->month = month;
this->day = day;
}
private:
int year;
int month;
int day;
};
6. 类的作用域
先说一个 C++ 的常识,花括号括起来的就算做一个 域
类定义了一个新的作用域,类的所有成员都在类的作用域中。在类体外定义成员时,需要使用 :: 作用域操作符指明成员属于哪个类域。
之前讲过的 命名空间 是 用于 名字隔离
而 类的作用域也有名字隔离的作用:
例如:下面演示的 栈 和 队列 两个类,都有初始化函数 Init() ,重名但不报错,就是因为 类域 进行了名字隔离
class Stack // 栈 的类
{
public:
void Init()
{
// ....
}
};
class Queue // 队列 的类
{
public:
void Init()
{
// ....
}
};
因此,想要使用指定一个 类的 成员函数,需要向 命名空间一样,要指定使用
Stack::Init / Queue::Push 像这种指定写法
同时这里也演示了:声明和定义分离的方法
class Stack // 栈 的类
{
public:
void Init(); // 定义
};
class Queue // 队列 的类
{
public:
void Push(); // 定义
};
// Stack:: 指定 Init这个函数属于 Stack 这个类
void Stack::Init() // 具体实现
{
// .....
}
// Queue:: 指定 Init这个函数属于 Queue 这个类
void Queue::Push() // 具体实现
{
// .....
}
7. 【面试题】谈一谈在面向对象中, 什么是封装呢?
面向对象的三大特性:封装、继承、多态。(这个是三大特性,不是只有这三个)
在类和对象阶段,主要是研究类的封装特性,那什么是封装呢?
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互。 封装本质上是一种管理,让用户更方便使用类。
比如:对于电脑这样一个复杂的设备,提供给用 户的就只有开关机键、通过键盘输入,显示器,USB插孔等,让用户和计算机进行交互,完成日 常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。 对于计算机使用者而言,不用关心内部核心部件,比如主板上线路是如何布局的,CPU内部是如 何设计的等,用户只需要知道,怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计 算机厂商在出厂时,在外部套上壳子,将内部实现细节隐藏起来,仅仅对外提供开关机、鼠标以 及键盘插孔等,让用户可以与计算机进行交互即可。
又比如:洗衣机,我们只用知道怎么使用洗衣机就好,不用知道内部洗衣机怎么运行的
核心:在C++语言中实现封装,可以通过类将数据以及操作数据的方法进行有机结合,通过访问权限来隐藏对象内部实现细节,控制哪些方法可以在类外部直接被使用。
8. 类的实例化(类是房子图纸,实例化对象是建造的房子)
用类类型创建对象的过程,称为类的实例化
1、类是对对象进行描述的,是一个模型一样的东西,限定了类有哪些成员,定义出一个类并没 有分配实际的内存空间来存储它;比如:入学时填写的学生信息表,表格就可以看成是一个 类,来描述具体学生信息。
2、一对多的关系:一个类可以实例化出多个对象,实例化出的对象占用实际的物理空间,存储类成员变量(一个类可以有多个对象,这么说类的确是海王(doge))
3、通俗的比方:类实例化出对象就像现实中使用建筑设计图建造出房子,类就像是设计图,只设出需要什么东西,但是并没有实体的建筑存在,同样类也只是一个设计,实例化出的对象才能实际存储数据,占用物理空间
9. 类对象模型(关于计算类的大小)
9.1 为什么可以计算类的大小?
上面将 类 比作房屋的图纸,我们在没有实际建造房子的前提下,可不可以知道总共需要即建造多大的房子?
是可以的
图纸设计房子的时候,已经标注好房子的占地面积等等
因此同理,类的大小也可以计算,对象的大小也可以算
9.2 观察下面代码的结果:发现 类的成员函数不包括在类的大小中
这段代码的结果:
class Time // 日期类
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Time t;
cout << "类Time 的大小: " << sizeof(Time) << '\n';
cout << "Time的对象 t 的大小:" << sizeof(t) << '\n';
return 0;
}
可以发现 类 的大小 和 该类的对象 大小相等
又根据 内存对齐规则 (不了解的可以先自学,就是结构体内存对齐,本篇文章后面也有讲到),计算这三个成员变量 _year / _month / _day 的总大小刚好是 12
也就说明 计算一个类的大小时,并没有包括成员函数的大小
实际上,一个类的成员函数是公共使用的,不算进一个类的大小中
原因:每个对象中成员变量是不同的,但是调用同一份函数,如果按照此种方式存储,当一 个类创建多个对象时,每个对象中都会保存一份代码,相同代码保存多次,浪费空间。
9.3 以日期类举例:演示并解释为什么成员函数不包括在 类的大小中
class Time // 日期类
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Time t1; t1.Init(2024, 1, 1);
Time t2; t2.Init(1999, 8, 1);
return 0;
}
成员变量可以重复保存,因为在不同对象中,成员变量的值可以不同,存在差异性
// 成员变量的值可以不同
Time t1; t1.Init(2024, 1, 1);
Time t2; t2.Init(1999, 8, 1);
但是 成员函数 都是使用这个函数的同一个逻辑流程,没有差异性
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
因此,成员函数通常是放在一个公共区域(公共代码区),给这个类的不同对象调用使用,而一个对象只保存这个类的成员变量就好
9.4 【思考题】比较这三种类型的类的大小:思考空类的大小是多少
// 一、类中既有成员变量,又有成员函数
class A1 {
public:
void f1() {}
private:
int _a;
};
// 二、类中仅有成员函数
class A2 {
public:
void f2() {}
};
// 三、类中什么都没有---空类
class A3
{};
int main()
{
cout << "一、" << sizeof(A1) << '\n';
cout << "二、" << sizeof(A2) << '\n';
cout << "三、" << sizeof(A3) << '\n';
return 0;
}
运行结果:
非空类:该类中”成员变量”之和
空类:一个字节 (上面的 第二和第三种都是空类,第二种的函数不包括在一个对象的大小中,所以是空的)
为什么空类大小不是 0 ?
先问个问题,当你定义了一个 空类的对象,若这个空类的大小为 0,那你这个对象到底算不算定义出来了?(定义出来的空间为 0 ,开了个空气?如定义吗?doge )
要明白,定义是需要开空间的,不开空间怎么算作定义呢
因此,空类就使用一个字节,标识对象被定义出来,但这一个字不存储有效数据
9.5 得出结论
综上所述,可以得出结论
结论:一个类的大小,实际就是该类中”成员变量”之和,当然要注意内存对齐
注意空类的大小,空类比较特殊,编译器给了空类一个字节来唯一标识这个类的对象。
(C++空类大小不为 0 ,不同编译器设置不一样,VS 和 devc++ 设置为 1 )
10. 【拓展】结构体内存对齐规则
1、第一个成员在与结构体偏移量为0的地址处。
2、其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
注意:对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
VS中默认的对齐数为8
3、结构体总大小为:最大对齐数(所有变量类型最大者与默认对齐参数取最小)的整数倍。
4、如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整 体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。
【面试题】
(1)结构体怎么对齐? 为什么要进行内存对齐?
为什么说,不进行内存对齐,可能会执行两次内存访问?
(2)如何让结构体按照指定的对齐参数进行对齐?能否按照3、4、5即任意字节对齐?
可以通过 #pragma 这个预处理指令,来设置对齐数,一般设计默认对齐数为 偶数!!!
#pragma pack(1) // 设置默认对⻬数为1
#pragma pack() // 取消设置的对⻬数,还原为默认
如何取消对齐?
答:换种角度思考,取消了对齐数,本质是老实的计算变量的大小后相加,也就是对齐数设置成 1
修改了默认对齐数位 1 后,下面代码的结果即为 6(char+char+int = 6)
#pragma pack(1)
class A
{
private:
char _a;
char _b;
int _c;
};
int main()
{
cout << sizeof(A) << '\n';
return 0;
}
(3)什么是大小端?如何测试某台机器是大端还是小端,有没有遇到过要考虑大小端的场景
什么大端小端:
大端(存储)模式,是指数据的低位保存在内存的高地址中,而数据的高位,保存在内存的低地址中;
小端(存储)模式,是指数据的低位保存在内存的低地址中,而数据的高位,保存在内存的高地址中。
数据的大小端存储 是由 计算机硬件决定的,不是编译器
如 十进制数字:135 1 为高位,5 为低位
十六进制序列 : 0x 11 22 33 44 11 为高位, 44 为低位
大端存储:如下图(小端存储就反着来)
11. this 指针
11.1 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 << '\n';
}
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;
}
运行上面的代码,可得结果
疑问来了:
Date类中有 Init 与 Print 两个成员函数,函数体中没有关于不同对象的区分,那当d1调用 Init 函 数时,该函数是如何知道应该设置d1对象,而不是设置d2对象呢?
解决办法:
C++中通过引入this指针解决该问题,即:C++编译器给每个“非静态的成员函数“增加了一个隐藏 的指针参数,让该指针指向当前对象(函数运行时调用该函数的对象),在函数体中所有“成员变量” 的操作,都是通过该指针去访问。只不过所有的操作对用户是透明的(透明的意思是用户看不见),即用户不需要来传递,编译器自动完成。
代码演示
下面代码中,注释的代码,是编译器底层执行的程序(用户表面看不见)
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
// void Print(Date* this) // 编译器底层执行的程序:用 this 指针 接收 对象的地址
void Print()
{
// 编译器底层执行的程序:对 this 指针指向的对象的成员变量进行操作
// cout << this->_year << "-" << this->_month << "-" << this->_day << '\n';
cout << _year << "-" << _month << "-" << _day << '\n';
}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
int main()
{
Date d1, d2;
d1.Init(2022, 1, 11);
d2.Init(2022, 1, 12);
// 编译器底层执行的程序:把 对象 的指针传过去
// d1.Print(&d1);
d1.Print();
// d2.Print(&d2);
d2.Print();
return 0;
}
11.2 this指针的特性
this 指针是隐含的:this指针是“成员函数”第一个隐含的指针形参,一般情况由编译器通过ecx寄存器自动传 递,不需要用户传递
(1)实参和形参的位置不能直接写,编译器自己会写
自己写就是错的
d1.Print(&d1); // 错误的
d1.Print(); // 正确的
// 成员函数处:形参处不用你写
void Print(Date* this) // 错的
void Print() // 对的
(2)但是在 类里面可以用 this指针
这两种写法都是正确的
void Print()
{
// 编译器底层执行的程序:对 this 指针指向的对象的成员变量进行操作
cout << this->_year << "-" << this->_month << "-" << this->_day << '\n';
cout << _year << "-" << _month << "-" << _day << '\n';
}
(3) this指针的类型:类类型* const,表示 在成员函数中,不能给this指针赋值(this 被 const 修饰,使其不能被修改)
void Print(Date* const this) // 编译器内部的写法 this 是 *const 类型
{
this = nullptr; // 这里会报错:成员函数内部不能修改 this 指针
cout << _year << "-" << _month << "-" << _day << '\n';
}
12. 三道大厂面试题:考察对 this 指针的理解
(1)关于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;
}
本题的思路:
首先,访问空指针(类似解引用)会报 运行错误,不会报编译错误,所以先排除 A
访问空指针(类似解引用)才可以获取到该指针所指向的空间内容,同时要调用使用一个函数,在编译链接阶段,就需要获取到这个函数的地址(底层来看)
我们需不需要在 指针 p 所指向的对象中,获取Print函数的地址?即需不需要访问指针p ?
答:不需要
因为在前面这一节【类对象模型(关于计算类的大小)】讲解过,成员函数都放在公共代码区域,而不是在 对象 中,因此我们不需要在指针 p 所指向的对象中找 Print函数,也就不需要访问指针p
因此答案选 C
我们调用 Print 函数时,会将对象指针 p 传过去作为 this 指针,我们仅仅是传递这个指针,没有进行访问,
到 Print 函数处,也没有访问这个指针,那怎样算作在成员函数处访问呢?看下一道例题
(2)关于this指针为空指针 题二
本段程序和上面一题很相似,注意辨别
// 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
报错:涉及空指针的访问
本题思路:
根据上一道例题的思路,在 main 函数中传递空指针过去作为 this 指针是没有错的(因为不涉及指针的访问)
又因为【1、this指针的指出 的 代码演示】这一节中提到: 底层会给成员函数加上一个 this 指针用于接收对象的地址
void Print(Date* this) // 编译器底层执行的程序:用 this 指针 接收 对象的地址
同时在函数中,会加上 this-> 表示访问这个 this指针所指空间中的成员
// 编译器底层执行的程序:对 this 指针指向的对象的成员变量进行操作
cout << this->_year; // 编译器底层加上 this->
cout << _year; // 你自己写的
因此本题中:
cout << _a << endl;
cout << this->_a << endl; // 底层加上 this->
这里就涉及了 this 指针的访问!!!!(警觉了)
由此,我们传过去的 this指针是空指针,导致产生空指针访问的问题,运行崩溃
(3)this指针存在哪里?
先列举几个存储区:栈、堆、静态区、常量区、对象里面
首先排除 “对象里面” :在之前【类对象模型(关于计算类的大小)】这一节中,得出结论:对象的大小就是成员变量内存对齐后的大小,因此不包括 this指针
最后答案是:栈
因为 this指针算作 形参,形参一般存储于 栈 中
另外,this指针也可能存储在 ecx寄存器中
例如 VS 中,会将对象 d1 的指针放到 ecx寄存器中(x86 环境下,即 64 位)(注意:x64 即 32位环境下,是 rcs寄存器,这个和ecx寄存器类似)
源码:可以自己将下面代码转为 反汇编 ,即可得到上面的汇编代码
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << '\n';
}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
int main()
{
Date d1;
d1.Init(2022, 1, 11);
d1.Print();
return 0;
}