面向对象:OO, Object - Oriented
面向过程:PO, Procedure - Oriented
C语言是「面向过程」的,关注的是「过程」,分析出求解问题的步骤,通过函数调用逐步解决问题。
C++是「基于面向对象」的,关注的是「对象」,将一件事情拆分成不同的对象,靠对象之间的交互完成。
注意:C++不是纯面向对象语言,C++既有面向过程(因为兼容C语言),也有面向对象,可以混合编程。
比如:
炒一盘菜:
面向过程关注的是过程,即炒菜的每个步骤(切菜、开火、放油、加佐料,炒…)。
面向对象关注的是对象,则会创建一个厨师类,然后在类中添加炒菜的方法,然后实例化厨师对象,调用炒菜方法。
区别一:
/**************************************************************/
// 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
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
{
// ...
};
类中的元素称为类的成员:
- 类中的数据,称为 类的属性 或 成员变量;
- 类中的函数,称为 类的方法 或 成员函数。
类的两种定义方式:
总结:
一般情况下,短的成员函数,声明和定义都放在类体中;长的函数,声明和定义分离,这样也能够更清楚的看到类的结构。
访问限定符分为三种:
- 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。
【面试题】 面向对象的三大特性:封装、继承、多态。
在类和对象阶段,我们只研究类的封装特性,那什么是封装呢?
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行
交互。
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;
}
用类类型创建对象的过程,称为类的实例化:
- 类只是一个模型一样的东西,限定了类有哪些成员,定义出一个类并没有分配实际的内存空间来存储它。
- 一个类可以实例化出多个对象,实例化出的对象占用实际的物理空间,存储类成员变量。
- 举个例子:现实中使用建筑设计图建造出房子,类就像是设计图,并没有实体的建筑存在。根据图纸建造出的房子,才能住人。同样,类也只是一个设计图,实例化出的对象才能实际存储数据,占用物理空间。
注意:
- 成员变量的定义是指:给变量分配了空间,跟是否初始化没有关系。
- 成员变量是存在对象中的,对象实例化时,才是它们定义的地方。
class Person
{
public:
void PrintInfo(); // 对于成员函数,这是声明
private:
char _name[20]; // 对于成员变量,这是声明(告诉你变量的类型、名称,但是没有开空间)
int _age;
};
void Person::PrintInfo() // 对于成员函数,这是定义(实现)
{
cout << _name << " " << _age << endl;
}
每个对象中成员变量是不同的,但是调用同一份函数,如果把成员变量和成员函数都存储在对象中,当一个类创建多个对象时,每个对象中都会多一份代码,相同代码保存多次,浪费空间。那么如何解决呢?
只保存成员变量,成员函数存放在公共的代码段。
总结:
实例化了一个对象后,系统会为该对象的数据成员分配存储空间,以存放该对象的各个数据成员(注意:分配的存储空间不包括成员函数的空间)
同一个类的不同对象其数据成员的值是不同的,而成员函数代码是相同的,所以存放对象时只需要存储自己的数据成员,而同一个类的各个对象的成员函数可以共用一份(单独存放在对象之外的另一段存储空间中)
① 计算一个类对象的大小
类对象大小:类对象中只存储了成员变量,所以只计算成员变量的大小(需要进行内存对齐)
示例:
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;
}
结构体的对齐规则:
第一个成员变量在与结构体变量偏移量为 0 的地址处。
其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
对齐数 =「编译器默认的一个对齐数」与「该成员大小」中的较小值。
VS中默认对齐数为「8」,Linux中没有对齐数。
结构体总大小为:最大对齐数(「所有成员变量中对齐数的最大者」与「默认对齐数」取最小)的整数倍。
如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。
面试题:
结构体怎么对齐? 为什么要进行内存对齐?
大部分的参考资料是这样说的:
- 平台原因(移植原因): 不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据,否则抛出硬件异常。(那我们就要将数据对齐到能够访问的这些地址处)
- 性能原因:数据结构(尤其是栈)应该尽可能地在自然边界上对齐。 原因在于,为了访问未对齐的内存,处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。
如何让结构体按照指定的对齐参数进行对齐?
什么是大小端?如何测试某台机器是大端还是小端,有没有遇到过要考虑大小端的场景?
拿日期类举例:
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);
}
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指向对象a
p->_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,所以崩溃了。