文章目录
-
-
- 一、初步认识面向过程和面向对象
- 二、类的引入
-
- C 和 C++ 中「 struct 」的区别
- 三、类的定义
- 四、类的访问限定符及封装
-
- 4.1 类的访问限定符
- 4.2 类的封装
- 五、类的作用域
- 六、类的实例化
-
- 6.1 类成员的声明与定义(要搞清楚)
- 七、类对象模型
-
- 7.1 类对象的存储方式
- 7.2 计算类对象的大小
- 7.3 结构体内存对齐规则
- 八、this 指针
-
- 8.1 this 的引出
- 8.2 this 指针的特性
-
一、初步认识面向过程和面向对象
面向对象:OO, Object - Oriented
面向过程:PO, Procedure - Oriented
C语言是「面向过程」的,关注的是「过程」,分析出求解问题的步骤,通过函数调用逐步解决问题。
C++是「基于面向对象」的,关注的是「对象」,将一件事情拆分成不同的对象,靠对象之间的交互完成。
注意:C++不是纯面向对象语言,C++既有面向过程(因为兼容C语言),也有面向对象,可以混合编程。
比如:
炒一盘菜:二、类的引入
面向过程关注的是过程,即炒菜的每个步骤(切菜、开火、放油、加佐料,炒…)。
面向对象关注的是对象,则会创建一个厨师类,然后在类中添加炒菜的方法,然后实例化厨师对象,调用炒菜方法。
C 和 C++ 中「 struct 」的区别 区别一:
/**************************************************************/
// c
struct ListNode
{
int val;
struct ListNode* next;
// c语言中必须要写struct
};
typedef struct ListNode // typedef
{
int val;
struct ListNode* next;
// 即使用了typedef,如果在结构体内,也必须要写struct
};
// 解析:
// C语言中struct是结构体
// 而 struct ListNode 这个整体是结构体名,必须要写全,不能省略struct
// typedef struct ListNode 在结构体结束的位置才会生效,所以在结构体内必须写全/**************************************************************/
// cpp
struct ListNode
{
int val;
ListNode* next;
// cpp中可以不写struct
};
// 解析:
// C++中struct不仅仅是结构体,struct已经升级成类了
// 而 ListNode 就是类名,ListNode* next 中的 ListNode 就是类名
// 所以我们可以不用写struct,当然也可以写上,因为cpp兼容c
【C++|【C++】类和对象(一)】区别二:
C语言中:数据和方法分离,结构体内只能定义变量。
C++中:数据和方法是封装在一起的,结构体内既可以定义变量,也可以定义函数。
/**************************************************************/
// c
struct Student
{
char _name[10];
// 数据
int _age;
};
// 方法(必须传结构体指针)
void SetStudentInfo(struct Student* ps, const char* name, int age)
{
strcpy(ps->_name, name);
ps->_age = age;
}int main()
{
Student s;
s.SetStudentInfo(&s, "winter", 20);
}/**************************************************************/
// cpp
struct Student
{
// 方法
void SetInfo(const char* name, int age) // 思考:为什么cpp中不用传结构体指针了呢?
{
strcpy(_name, name);
_age = age;
} char _name[10];
// 数据
int _age;
};
int main()
{
Student s;
s.SetInfo("winter", 20);
}
上面结构体的定义,在 C++ 中更喜欢用 class 来代替。
三、类的定义
class为定义类的关键字,
ClassName
为类的名字,{}
中为类的主体,注意类定义结束时后面分号。class className
{
// ...
};
类中的元素称为类的成员:
类的两种定义方式:
- 类中的数据,称为 类的属性 或 成员变量;
- 类中的函数,称为 类的方法 或 成员函数。
总结:
- 声明和定义全部放在类体中,需要注意:成员函数如果在类中定义,编译器可能会将其当成内联函数处理。
文章图片
- 声明放在 .h 文件中,定义放在 .cpp 文件中。
文章图片
一般情况下,短的成员函数,声明和定义都放在类体中;长的函数,声明和定义分离,这样也能够更清楚的看到类的结构。
四、类的访问限定符及封装
4.1 类的访问限定符 访问限定符分为三种:
访问限定符说明:
- public(公有)
- protected(保护)
- private(私有)
注意:
public
修饰的成员在「类外」可以直接被访问
protected
和private
修饰的成员在「类外」不能直接被访问
(注:此处protected
和private
是类似的,继承时才能够更好的体现它们的区别)
- 访问权限作用域从该访问限定符出现的位置开始,直到下一个访问限定符出现时为止
- C++中的 class 的默认访问权限为 private,struct 的默认访问权限为 public(因为 struct 要兼容C)
class A // 默认访问权限是private { // ... }; struct A// 默认访问权限是public { // ... };
- 所以:类中的成员,我想让你在类外面访问的,设置成公有;我不想让你在类外面访问,设置成私有。
访问限定符只在编译时有用,当数据映射到内存后,没有任何访问限定符上的区别【面试题】C++中 struct 和 class 的区别是什么?
解答:C++需要兼容C语言,所以 C++ 中 struct 可以当成结构体去使用。另外 C++ 中 struct 还可以用来定义类。和 class 是定义类是一样的,唯一的区别是: struct 的成员默认访问权限是 public,class 是的成员默认访问权限是 private。4.2 类的封装 【面试题】 面向对象的三大特性:封装、继承、多态。
在类和对象阶段,我们只研究类的封装特性,那什么是封装呢?
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行
交互。
C++实现封装的方式:
用类将对象的属性与方法结合在一块,让对象更加完善,通过访问权限,有选择性的将其接口提供给外部的用户使用。类的定义和设计就体现了封装的思想:
封装本质上是一种管理:
- C语言中,没有封装,数据和方法分离,比较自由,任何人都可以随便访问数据和方法。
- C++中,有封装,数据和方法都放到类里面,同时想给你访问的,定义成公有;不想给你访问的,定义成私有。
我们如何管理兵马俑呢?C语言相当于什么都不管,不设防护栏,万一访问的人素质差,兵马俑就被随意破坏了。而 C++ 就相当于建了一座房子把兵马俑给封装起来。但不是封的死死的,不让别人看。可以参观的部分,设置售票通道,可以买票突破封装,并在合理的监管机制下进去参观。五、类的作用域
类也是一样,我们把类中的数据和方法都封装到一下,不想给别人看到的,我们使用 protected / private 把成员封装起来。开放一些公有的成员函数对成员合理的访问。所以封装本质是一种管理。
封装能够更好的规范代码。小伙子不要不讲码德呀!
花括号
{}
括起来的都是一个域。类定义了一个新的作用域,类的所有成员都在类的作用域中。
如果在类体外定义成员,需要使用
::
作用域解析符指明成员属于哪个类域。class Person
{
public:
void PrintInfo();
private:
char _name[20];
int _age;
};
// 这里需要指定PrintInfo是属于Person这个类域
void Person::PrintInfo()
{
cout << _name << " " << _age << endl;
}
六、类的实例化
用类类型创建对象的过程,称为类的实例化:
6.1 类成员的声明与定义(要搞清楚) 注意:?
- 类只是一个模型一样的东西,限定了类有哪些成员,定义出一个类并没有分配实际的内存空间来存储它。
- 一个类可以实例化出多个对象,实例化出的对象占用实际的物理空间,存储类成员变量。
- 举个例子:现实中使用建筑设计图建造出房子,类就像是设计图,并没有实体的建筑存在。根据图纸建造出的房子,才能住人。同样,类也只是一个设计图,实例化出的对象才能实际存储数据,占用物理空间。
文章图片
- 成员变量的定义是指:给变量分配了空间,跟是否初始化没有关系。
- 成员变量是存在对象中的,对象实例化时,才是它们定义的地方。
class Person
{
public:
void PrintInfo();
// 对于成员函数,这是声明private:
char _name[20];
// 对于成员变量,这是声明(告诉你变量的类型、名称,但是没有开空间)
int _age;
};
void Person::PrintInfo() // 对于成员函数,这是定义(实现)
{
cout << _name << " " << _age << endl;
}
七、类对象模型
7.1 类对象的存储方式 每个对象中成员变量是不同的,但是调用同一份函数,如果把成员变量和成员函数都存储在对象中,当一个类创建多个对象时,每个对象中都会多一份代码,相同代码保存多次,浪费空间。那么如何解决呢?
只保存成员变量,成员函数存放在公共的代码段。
总结:
文章图片
7.2 计算类对象的大小 ① 计算一个类对象的大小
- 实例化了一个对象后,系统会为该对象的数据成员分配存储空间,以存放该对象的各个数据成员(注意:分配的存储空间不包括成员函数的空间)
- 同一个类的不同对象其数据成员的值是不同的,而成员函数代码是相同的,所以存放对象时只需要存储自己的数据成员,而同一个类的各个对象的成员函数可以共用一份(单独存放在对象之外的另一段存储空间中)
类对象大小:类对象中只存储了成员变量,所以只计算成员变量的大小(需要进行内存对齐)
示例:
class A
{
public:
void func1() { cout << "func1" << endl;
}
void func2() { cout << "func2" << endl;
}
void func3() { cout << "func3" << endl;
}private:
int _a;
int _b;
};
int main()
{
A a;
cout << sizeof(a) << endl;
// 输出:8 return 0;
}
② 计算一个类的大小
注意:算一个类型的大小,本质是算这个类型定义出的一个对象的大小,因为类型本身是不占空间的。
总结:
示例:
- 一个类的大小,实际就是该类中 ” 成员变量 ” 之和(需要进行内存对齐)
- 注意空类的大小,空类比较特殊,编译器给了空类 1 个字节来唯一标识这个类。
- 如果一个类没有成员变量,是一个空类,那么它的对象需要给 1 字节进行占位,表示其对象存在,这 1 字节不存储有效数据。
- 那么空类有意义吗? – 有的,比如后面要学习的仿函数。
// 类中既有成员变量,又有成员函数
class A {
public:
void func() {}private:
int _a;
};
// 类中仅有成员函数
class B {
public:
void func() {}
};
// 空类
class C
{};
int main()
{
cout << sizeof(A) << endl;
// 输出:4
cout << sizeof(B) << endl;
// 输出:1
cout << sizeof(C) << endl;
// 输出:1 return 0;
}
7.3 结构体内存对齐规则 结构体的对齐规则:
面试题:
- 第一个成员变量在与结构体变量偏移量为 0 的地址处。
- 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
- 对齐数 =「编译器默认的一个对齐数」与「该成员大小」中的较小值。
- VS中默认对齐数为「8」,Linux中没有对齐数。
- 结构体总大小为:最大对齐数(「所有成员变量中对齐数的最大者」与「默认对齐数」取最小)的整数倍。
- 如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。
八、this 指针
- 结构体怎么对齐? 为什么要进行内存对齐?
大部分的参考资料是这样说的:
- 平台原因(移植原因): 不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据,否则抛出硬件异常。(那我们就要将数据对齐到能够访问的这些地址处)
- 性能原因:数据结构(尤其是栈)应该尽可能地在自然边界上对齐。 原因在于,为了访问未对齐的内存,处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。
- 如何让结构体按照指定的对齐参数进行对齐?
- 什么是大小端?如何测试某台机器是大端还是小端,有没有遇到过要考虑大小端的场景?
8.1 this 的引出 拿日期类举例:
class Date
{
public:
void Display()
{
cout << _year << "-" << _month << "-" << _day << endl;
} void SetDate(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}private:
int _year;
// 年
int _month;
// 月
int _day;
// 日
};
int main()
{
Date d1;
// 实例化对象d1
Date d2;
// 实例化对象d2
d1.SetDate(2021, 10, 8);
d2.SetDate(2022, 10, 8);
d1.Display();
d2.Display();
return 0;
}
对于上述类,思考这样的一个问题:
Date 类中有 SetDate 与 Display 两个成员函数,函数体中没有关于不同对象的区分,那当 d1 调用 SetDate 函数时,该函数是如何知道应该设置 d1 对象,而不是设置 d2 对象呢?成员函数怎么辨别当前调用自己的是哪个对象呢?—— 隐含的 this 常量指针(它指向了调用自己的对象)
C++中通过引入 this 指针解决该问题,即:C++编译器给每个 “ 非静态的成员函数 “ 增加了一个隐含的「常量指针」参数,让该指针指向调用本函数的对象,在函数体中对所有成员变量的操作,都是通过该指针去访问。只不过所有的操作对用户是透明的,即用户不需要来传递,编译器自动完成。现在再来看刚才写的日期类:
文章图片
成员函数隐含的 this 指针指向哪个对象,在成员函数中就可以通过 this 指针来访问哪个对象中的数据。
class Date
{
public:
// 编译器会解释为:void Display(Date* const this)
void Display()
{
cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
}
// 编译器会解释为:void SetDate(Date* const this, int year, int month, int day)
void SetDate(int year, int month, int day)
{
this->_year = year;
this->_month = month;
this->_day = day;
// 成员函数内,可以显示的在成员前加上 this->
// 我们不加的话,默认也会在成员前加上 this->this->Display();
// 成员函数中还可以调成员函数,因为有 this 指针
}private:
int _year;
// 年
int _month;
// 月
int _day;
// 日
};
int main()
{
Date d1;
Date d2;
d1.SetDate(2021, 10, 8);
// 编译器会解释为:d1.SetDate(&d1, 2021, 10, 8);
d2.SetDate(2022, 10, 8);
// 编译器会解释为:d2.SetDate(&d2, 2022, 10, 8);
d1.Display();
// 编译器会解释为:d1.Display(&d1);
d2.Display();
// 编译器会解释为:d2.Display(&d2);
return 0;
}
最后再回想一下 C 语言中,方法是怎么辨别当前调用自己的是哪个对象呢,其实原理和C++是一样的。
看完下面这段 C 语言代码,你就能够更好的理解 this 指针了。
在C语言中,数据和方法分离,方法必须要传结构体指针,指向调用该方法的结构体对象,这样才能在方法中访问这个对象中的数据。
// c
struct Student
{
char _name[10];
// 数据
int _age;
};
// 思考:为什么这里必须传结构体指针呢?
void SetStudentInfo(struct Student* ps, const char* name, int age)
{
strcpy(ps->_name, name);
// p类比cpp的this->
ps->_age = age;
}int main()
{
Student s;
s.SetStudentInfo(&s, "winter", 20);
}
8.2 this 指针的特性
- this 指针的类型:
类类型* const this
,是一个常量指针,所以 this 指针的指向是不能更改的。
- 只能在 “ 非静态的成员函数 ” 的内部使用,静态成员函数是没有 this 指针的。
- this 指针本质上其实是一个成员函数的形参,是对象调用成员函数时,将对象地址作为实参传递给 this 形参。所以对象中不存储 this 指针。
- this 指针是成员函数第一个隐含的指针形参(VS中一般由编译器通过 ecx 寄存器自动传递),不需要用户传递。
① this 指针是存在哪里的?(栈 / 堆 / 静态区 / 常量区)
常犯的错误:this 指针是存在对象里面的。
this 指针是形参,形参和函数中的局部变量都是存在函数栈帧里面的,所以 this 指针可以认为是存在栈中的。
注:VS下为了提高效率,this 指针是通过寄存器 ecx 传递的,如图:
拓展:去 Linux 中验证 gcc 下,this 指针是存在哪里的?
文章图片
② this 指针可以为空吗?
请看下面这两道题:
- 下面程序的运行结果是什么? A. 编不译通过;B. 运行崩溃;C. 正常运行
class A { public: void Show() { cout << "Show()" << endl; }private: int _a; }; int main() { A* p = nullptr; p->Show(); }
答案解析:正常运行
成员函数的地址不存在对象中,存在公共代码段,那么这里调用成员函数,会去 call 函数的地址,不会去访问 p 指向的空间,也就不存在空指针解引用了。这里是把 p 传递给 Show 函数隐含的 this 指针形参,而 Show 函数中也没有对 this 指针解引用,所以正常运行。
补充:
A a; A* p = &a; // p指向对象ap->_a; // 这里是在p指向的空间上(即对象a的空间)访问(对象a的)成员_a,是一个解引用行为 p->Show(); // 这里只是把p(对象a的地址)传递给Show函数隐含的this指针形参,没有解引用
- 下面程序的运行结果是什么? A. 编不译通过;B. 运行崩溃;C. 正常运行
class A { public: void PrintA() { cout << _a << endl; }private: int _a; }; int main() { A* p = nullptr; p->PrintA(); }
答案解析:运行崩溃
因为函数中的this->_a
,要访问对象的成员变量 _a,需要对 this 指针解引用,才能访问到对象中的数据,而传入的对象地址是 nullptr,所以 this 指针也是 nullptr,所以崩溃了。
推荐阅读
- C语言进阶|【C语言进阶16——通讯录(基础版、动态内存版、文件管理版)】
- qt|QCustomPlot开发笔记(一)(QCustomPlot简介、下载以及基础绘图)
- Java每日一练|Java基础每日一练—第8天(判断大小)
- JavaSE系列详解|新星计划day4【Java语言IO流】缓冲流的详解
- Java每日一练|Java基础每日一练—第7天(最优选择)
- JavaSE系列详解|Java基础IO流之序列化流的使用
- AM 218问题3解答
- Comp 218/EC基础讲解
- C/C++气象数据中心实战,手把手教你做工业级项目(源码齐全)