目录

引言

面向过程与面向对象

1.面向过程

2.面向对象

类

1.类的定义

2.类的访问限定符

3.类域

4.类域与其他作用域

对象

1.类对象的实例化

2.对象的大小

2.1 如何计算对象的大小

2.2 内存对齐规则

2.3 示例

3.this指针

3.1 this指针的引入

3.2 this指针的详细说明

结束语

---

引言

在C++中，类和对象是面向对象编程（OOP）的基石。它们允许开发者将数据和操作数据的函数组合在一起，形成一个独立的实体，这个实体就是对象，而描述这些对象的蓝图则称为类。

下面我们将来学习C++中类和对象。

面向过程与面向对象

面向过程和面向对象在编程思想、设计方式和实现方法上有着明显的区别。

1.面向过程

C语言是一种面向过程的语言，它强调事件的具体实现过程，程序的执行流程主要由函数的调用和控制流语句（如条件语句和循环语句）组成。

优点：

性能高：由于面向过程编程直接关注算法和流程控制，因此其执行效率通常较高，特别是在资源受限的环境（如单片机、嵌入式开发）中。

易于理解：对于简单的程序，面向过程的逻辑更加直观，易于理解和实现。

缺点：

代码重用性差：随着程序复杂度的增加，面向过程编程中的代码重用变得困难，因为函数之间的耦合度较高。

可维护性差：当程序规模扩大时，面向过程编程的代码难以维护，因为需要追踪大量的函数调用和依赖关系。

扩展性差：在面向过程编程中，添加新功能可能需要修改大量的函数和流程，导致扩展困难。

2.面向对象

C++是一门典型的面向对象的语言。在面向对象编程中，程序被组织为一组相互协作的对象，这些对象通过消息传递来进行交互和处理。

对象是对现实世界中某个具体或抽象事物的抽象表示，每个对象都具有状态（属性）和行为（方法）。

优点：

代码重用性高：通过封装和继承等机制，面向对象编程可以方便地重用代码，减少重复编写。

可维护性好：面向对象编程将代码组织成模块化的结构，使得代码更易于理解、修改和调试。

可扩展性强：通过继承和多态等特性，面向对象编程可以方便地添加新功能或修改现有功能，而不需要修改大量的代码。

缺点：

性能较低：由于面向对象编程涉及到更多的抽象和封装，因此在执行时可能需要更多的内存和处理器资源，导致性能较低。然而，这种性能差异在大多数现代计算机系统中并不明显。

复杂性增加：面向对象编程的概念和语法可能较为复杂，需要一定的时间来学习和掌握。

类

在C++中，在原来C语言结构体的基础上引入了类的概念。与C语言最大的不同就是，C++可以在类中定义函数。而由类声明定义的变量，我们称为对象。

1.类的定义

class 为定义类的关键字，后跟类名和一对花括号 { } ，花括号内包含了类的成员声明。成员可以是数据成员（也称为属性或字段）或成员函数（也称为方法）。

语法如下：

<code>class className

{

// 类体：由成员函数和成员变量组成

};

还是来看个简单的例子：

class Myclass

{

int x; //成员变量

void myFunction(); //成员函数

};

在上面的例子中，MyClass是一个类，它有一个成员变量x和一个成员函数myFunction。

注意事项：

1.为了区分成员变量，一般习惯上成员变量会加⼀个特殊标识，如成员变量前面或者后面加_或者m 开头，注意C++中这个并不是强制的，只是⼀些惯例，具体看公司的要求。

2.C++中struct也可以定义类，C++兼容C中struct的用法，同时 struct 升级成了类，明显的变化是 struct中可以定义函数，一般情况下我们还是推荐用class定义类。

3.定义在类面的成员函数默认为inline

2.类的访问限定符

类的访问限定符（Access Specifiers）在面向对象编程中扮演着至关重要的角色，它们定义了类成员的访问权限，即决定了哪些成员可以在类的外部被访问，哪些只能在类的内部或派生类中被访问。

C++中主要有三种访问限定符：public、protected 和 private。

public：使用public修饰的类成员（包括数据成员和成员函数）可以在类的外部被访问。

protected：protected成员在类的内部和派生类（子类）中可以被访问，但在类的外部不可访问。

private：private成员只能在类的内部被访问，类的外部和派生类都无法直接访问这些成员。

这是一个日期类的简单示例：

class Date

{

public:

// 类中定义默认为内联函数

void Init(int year, int month, int day)

{

_year = year;

_month = month;

_day = day;

}

private:

// 一般习惯上成员变量会加⼀个特殊标识

// 如成员变量前面或者后面加_或者m 开头

int _year; // year_ m_year

int _month;

int _day;

};

3.类域

定义：类域指的是在类中定义的名称（包括成员变量和成员函数）所具有的作用范围。这些名称在类的内部是可见的，但在类外部则不可见（除非通过特定的方式，如通过对象或类名加作用域解析运算符 :: 来访问）。

类域影响的是编译的查找规则。下⾯程序中Init如果不指定类域Stack，那么编译器就把Init当成全 局函数，那么编译时，找不到array等成员的声明/定义在哪⾥，就会报错。指定类域Stack，就是知 道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找。

#include<iostream>

using namespace std;

class Stack

{

public:

// 成员函数

void Init(int n = 4);

private:

// 成员变量

int* array;

size_t capacity;

size_t top;

};

// 声明和定义分离，需要指定类域

void Stack::Init(int n)

{

array = (int*)malloc(sizeof(int) * n);

if (nullptr == array)

{

perror("malloc申请空间失败");

return;

}

capacity = n;

top = 0;

}

int main()

{

Stack st;

st.Init();

return 0;

}

4.类域与其他作用域

全局作用域：全局作用域是程序中所有全局变量和函数的作用范围。在全局作用域中定义的名称在整个程序中都是可见的，但它们在类域内部是不可见的，除非通过特定的方式（如使用::作用域解析运算符）显式地引用它们。

局部作用域：局部作用域是在函数、控制结构（如if语句、循环）或代码块中定义的。在局部作用域中定义的名称仅在该作用域内部可见。它们与类域完全隔离，即使它们位于类的成员函数内部。

类域：类域是类中成员的作用范围。在类域中定义的名称（成员变量和成员函数）仅在该类内部可见，除非它们被声明为public、protected或static（对于静态成员，其可见性还取决于访问控制修饰符，但它们的生命周期和存储位置与实例无关）。

命名空间作用域：命名空间作用域是C++中用于组织代码和防止命名冲突的一种机制。命名空间可以包含函数、变量、类和其他命名空间。在命名空间作用域中定义的名称仅在该命名空间内部可见，但可以通过使用命名空间名称或使用using声明/指令来在更广泛的作用域中访问它们。

类域是C++中封装和隐藏实现细节的关键机制。它与其他作用域（如全局作用域、局部作用域、命名空间作用域）之间有明显的界限，但可以通过特定的机制进行交互。理解这些作用域之间的关系对于编写清晰、可维护和安全的C++代码至关重要。

对象

1.类对象的实例化

用类类型在物理内存中创建对象的过程，称为类实例化出对象。

类是对象进行⼀种抽象描述，是一个模型一样的东西，限定了类有哪些成员变量，这些成员变量只 是声明，没有分配空间，用类实例化出对象时，才会分配空间。一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。

打个比方：类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，设计图规划了有多少个房间，房间大小功能等，但是并没有实体的建筑存在，也不能住人，用设计图修建出房子，房子才能住人。同样类就像设计图⼀样，不能存储数据，实例化出的对象分配物理内存存储数据。

来看个简单的例子：

<code>#include<iostream>

using namespace std;

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

Date d1;

Date d2;

d1.Init(2024, 9, 1);

d1.Print();

d2.Init(2024, 9, 4);

d2.Print();

return 0;

}

2.对象的大小

对象在内存中的大小是由其成员变量决定的。成员函数不占用对象的空间，因为所有对象共享同一个成员函数实例。

C++中对象的大小可以通过sizeof运算符获得，但需要注意的是，该运算符返回的是对象在内存中占用的字节数，包括任何编译器插入的填充字节。

2.1 如何计算对象的大小

C++中对象的大小计算相对复杂，因为它涉及到类的定义和继承等因素：

空类：即使类中没有定义任何成员，其对象的大小也至少为1个字节。

非静态成员变量：对象的大小至少等于所有非静态成员变量大小的总和。

虚函数：如果类中声明了虚函数，那么编译器会在对象内部安插一个指向虚函数表的指针（vptr），这会增加对象的大小。

多重继承和虚继承：在多重继承和虚继承的情况下，对象的大小还会受到继承结构和虚基类指针（vbptr）等因素的影响。

对齐：编译器可能会在类的成员之间或类的末尾添加填充字节，以确保类的对象在内存中的对齐。这会影响对象的大小。

2.2 内存对齐规则

C++中对象的内存对齐规则与C语言中结构体的对齐规则是完全一致的。

(1)第⼀个成员在与结构体偏移量为0的地址处。

(2)其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

(3)对齐数=编译器默认的⼀个对齐数与该成员大小的较小值。以Visual Studio 为例，编译器默认的对齐数为8  

(4)结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。 

(5)如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

2.3 示例

#include<iostream>

using namespace std;

// 计算⼀下A/B/C实例化的对象是多⼤？

class A

{

public:

void Print()

{

cout << _ch << endl;

}

private:

char _ch;

int _i;

};

class B

{

public:

void Print()

{

//...

}

};

class C

{};

int main()

{

A a;

B b;

C c;

cout << sizeof(a) << endl;

cout << sizeof(b) << endl;

cout << sizeof(c) << endl;

return 0;

}

输出结果为：

我们可以看到：没有成员变量的B和C类对象的大小是1。即使类中没有定义任何成员，其对象的大小也至少为1个字节。

3.this指针

3.1 this指针的引入

先来看看这段代码：

<code>#include<iostream>

using namespace std;

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(2024, 9, 1);

d2.Init(2022, 9, 4);

d1.Print();

d2.Print();

return 0;

}

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 和 Print函数时，该函数是如何知道应该访问的是 d1 对象还是 d2 对象呢？

在C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数。通过不同的对象地址来分辨不同的对象，只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

其实际代码为：

void Init(Date* this, int year, int month, int day)

{

this->_year = year;

this->_month = month;

this->_day = day;

}

d1.Init(&d1,2022, 1, 11); //实际传参

3.2 this指针的详细说明

this 指针是 C++ 中的一个非常特殊的指针，它主要用于指向当前对象。当你在类的成员函数内部时，this 指针就代表了调用该成员函数的对象本身。通过 this 指针，你可以访问类的成员变量和成员函数，即使它们与当前成员函数同名。

主要用途

(1)访问成员变量和成员函数：在类的成员函数内部，你可以直接使用成员变量和成员函数的名字来访问它们，而不需要通过 this 指针。然而，在某些情况下（如参数名与成员变量名冲突时），使用 this 指针来明确指定你想要访问的是成员变量或成员函数是非常有用的。

(2)返回当前对象的引用或指针：在需要返回当前对象本身（或其引用、指针）的场合，this 指针非常有用。例如，在链表中实现节点的插入或删除操作时，可能需要返回当前节点或链表的头节点。

(3)作为函数参数传递：虽然直接将 this 指针作为参数传递给其他函数并不常见，但在某些特殊情况下（如回调函数），可能需要将 this 指针传递给另一个函数，以便在回调函数中访问调用它的对象的成员

注意事项

(1)this 指针是隐式传递的，你不需要在函数参数列表中显式地包含它。

(2)在静态成员函数中，this 指针是不可用的，因为静态成员函数不属于任何对象实例。

(3)在构造函数和析构函数中，this 指针同样有效，但需要注意的是，在构造函数中，this 指针指向的对象可能尚未完全构造完成（特别是当构造函数体中有其他成员变量的初始化时），而在析构函数中，对象已经处于析构过程中，因此应谨慎使用。（有关构造函数和析构函数我们会在后面学习到）。

结束语

本篇博客介绍一下C++中类与对象的一些知识。

求点赞收藏评论关注！！！

感谢大佬！！！