彼岸花开C++，类和对象（上）

敲代码的小马哥

已于 2024-08-11 13:30:18 修改

阅读量1.9k

点赞数 46

文章标签：笔记 c++

于 2024-08-06 11:15:22 首次发布

本文链接：https://blog.csdn.net/2401_86606773/article/details/140938889

版权

对于类的初步认识

（1）类的定义

class className
{
    // 类体，由成员函数和成员变量组成
}； // 一定要注意后面的分号
类体中内容称为类的成员：类中的变量称为类的属性或成员变量；类中的函数称为类的方法（成员函数）

类的两种定义方式：

1.声明和定义全放在类体中。（注：成员函数如果在类中定义，编译器可能会将其当成内联函数处理）
class Person
{
public:
    // 显示基本信息
    void show
    {
        cout << _name << " " << _sex << endl;
    }
private:
    int _name;
    int _sex;
}
2.类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

成员函数在外部定义：
// 声明放在类的头文件person.h中
class Person
{
public:
    void show();
private:
    int _name;
    int _sex;
};

（2）类的访问限定符及封装

面向对象的三大特性：封装，继承，多态。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。（封装本质上是一种管理，让用户更方便的使用类）

eg：对于计算机的使用者来说，不用关心内部核心零件，用户只需要知道怎么开机怎么用鼠标和键盘与计算机进行交互就行。

在C++语言中实现封装，可以通过类将数据以及操作方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外面直接被使用。

注：struct在C和C++中的区别：
struct ListNode_C
{
    int _val;
    struct ListNode_C* _next;
    struct ListNode_C* _prev;
};

struct ListNode_CPP
{
    int _val;
    struct ListNode_CPP* _next; // 兼容C的用法
    ListNode_CPP* _prev;

    // 还可以定义成员函数
    ListNode_CPP* CreateNode(int val);
};
1.C语言中struct是用来定义结构体的。

2.C++中，兼容C的struct定义结构体的用法。但是同时struct也可以用来定义类。

3.C++中使用struct定义类的区别：默认的访问限定符不同。(class默认私有，struct默认公有)。

（3）类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需使用::作用域操作符指明成员属于哪个类域。
class Person
{
public:
	void Print();
private:
	char _name[20];
	int _age;
};

// 这里需要指明Print()是属于Person这个类域
void Person::Print()
{
	cout << _name << ' ' << _age << endl;
}

（4）类的实例化

用类这个类型创建对象的过程，称为类的实例化

1.类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。（eg：入学时填的信息表，表格就可以看成是一个类，来描述具体的学生信息。）

2.一个类可以实例化出多个对象，实例化的对象，占用实际的物理空间，存储成员变量。
int main()
{
	Person._age = 100;
	// 编译失败。Person类是没有空间的，只有Person类实例化出的对象才会有具体的年龄
	return 0;
}
打个比方，类就像是房子的设计图纸，只设计出需要什么东西，但没有实体建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。
class Person
{
public:
	void Print();
public:
	char* _name;
	int _age;
};

int main()
{
	Person man;
	man._name = "jack";
	man._age = 10;
	
	return 0;
}

（5）类的对象大小的计算

问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象包含了什么？如何计算一个类的大小？

Answer：一个类的大小，实际就是该类中“成员变量”之和，当然要注意内存对齐。注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。
// 类中既有成员变量又有成员函数
class A1
{
public:
	void f1() {}
private:
	int _a;
};

// 类中仅有成员函数
class A2
{
public:
	void f2() {}
};

// 空类
class A3
{};

int main()
{
	cout << sizeof(A1) << endl;
	cout << sizeof(A2) << endl;
	cout << sizeof(A3) << endl;
}
运行结果：

问题：如何计算一个类实例化出的对象的大小

计算成员变量之和，并考虑内存对齐的规则，每个成员变量都有一个对齐数，这个对齐数=min(自己的大小，默认对齐数)（VS的默认对齐数为8），没有成员变量的类的大小为1

注：对象中只存储成员变量，不存储成员函数。一个类实例化出N个对象，每个对象的成员都可以存储不同的值，但是调用的函数确是同一个，如果每个对象都存储成员函数，而这些成员函数确是同一个，浪费空间。

思考：为什么没有成员变量的类的大小是1而不是0？

Answer：开一个字节不是为了存数据，而是占位表示数据存在

补充：结构体内存对齐规则：

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

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

注意：对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。(VS的默认对齐数为8)

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

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

（6）类成员函数的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 << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1, d2;
	d1.Init(2024, 8, 5);
	d2.Init(2024, 8, 6);
	d1.Print();
	d2.Print();

	return 0;
}
对于上述类，有这样的一个问题：
Date类中有Init与Print两个成员函数，函数体中没有关于不同对象的区分，那当d1调用Init函
数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

C++中通过引入this指针解决该问题：C++编译器给每个“非静态的成员函数”增加了一个隐藏的指针参数，让该指针指向当前对象（函数运行时调用该函数的对象），在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

this指针的特性：
1.this指针的类型：类类型*const，即成员函数中，不能给this指针赋值。
2.只能在“成员函数”的内部使用
3.this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给
this形参。所以对象中不存储this指针。
4.this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传
递，不需要用户传递
void Print()// 会有隐含的this指针（编译器处理）
{// void Print(Date* this)
    cout << this->_year << '-' << this->_month << '-' << this->_day << endl;
}
问题：

1.this指针存在哪里？(也就是进程空间的哪个区域？)

--> 存在栈上的，因为它是一个形参。（ps：vs下是在ecx这个寄存器，来传递）

2.this指针可以为空吗？

对于这个问题看下面一段程序
#include <iostream>

using namespace std;

class A
{
public:
    void PrintA()
    {
        cout << this->_a << endl;
    }
    void Show()
    {
        cout << "Show()" << endl;
    }
private:
    int _a;
};

int main()
{
    A* p = nullptr;
    p->PrintA(); // 这一行会引发什么?编译不通过？ 程序不通过？ 正常运行？
    p->Show();   // 这一行会引发什么?编译不通过？ 程序不通过？ 正常运行？
    
    return 0;
}
只运行p->PrintA()，程序崩溃，没有结果

只运行p->Show(),正常运行

p->PrintA(); // 访问了空指针，p->Show(); // 这一步并没有访问空指针，成员函数存在公共的代码段，所以p->show()这里不会去p指向的对象上去找。