类与对象（一）

夏同学...

已于 2022-03-06 12:28:13 修改

阅读量479

点赞数 4

分类专栏： C++ 文章标签： c++

于 2022-03-04 17:37:16 首次发布

本文链接：https://blog.youkuaiyun.com/xxtzzxx/article/details/123239443

版权

C++ 专栏收录该内容

6 篇文章

订阅专栏

本文介绍了C++中的面向对象编程概念，包括面向过程与面向对象的对比，类的引入、定义、封装、作用域以及实例化。详细讲解了类对象的存储方式和大小计算，强调了this指针的重要性及其特性。通过实例帮助理解面向对象编程的基本概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、什么是面向过程、面向对象？

1、面向过程

C语言是面向过程的典型代表，其关注的是解决问题的过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

2、面向对象

C++是基于面向对象的，其关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

3、形象说明

面向过程 -- 吃狗屎

面向对象 -- 狗吃屎（虽然比较恶心，但是话糙理不糙，希望你不是在边吃边看）

二、类

1、类的引入

事实上，C++中的类和C语言中的结构体的用法上有诸多的共通之处，C++兼容C中结构体的用法，同时也将struct升级成了类。下面代码有助于理解：

struct student
{
	void Init(char* name, int age, int id)
	{
		strcpy(_name, name);
		_age = age;
		_id = id;
	}

	void Print()
	{
		cout << _name << ' ' << _age << ' ' << _id << endl;
	}

	char _name[10];
	int _age;
	int _id;
};

int main()
{
	struct student s1 = {"王炸", 24, 2022};
	student s2 = { "憨豆", 23, 2021 };
	student s3;
	s3.Init("小花", 18, 2001);
	cout << s1._name << ' ' << s1._age << ' ' << s1._id << endl;
	cout << s2._name << ' ' << s2._age << ' ' << s2._id << endl;
	s3.Print();
	return 0;
}

从上面代码我们可以得出：

1）在用自定义类型结构体定义变量时，关键字struct是可以省略掉的

2）C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数

2、类的定义

1）在C++中，类的定义更习惯于用class来替代struct

2）访问限定符

作用：对类中成员的调用加以限制，使其对数据的管理更加严格，使用起来更加安全。

访问限定符说明
        1. public修饰的成员在类外可以直接被访问
        2. private修饰的成员在类外不能直接被访问
        3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
        4. class的默认访问权限为private，struct为public(因为struct要兼容C)

访问限定符的简单使用（包含对象对public部分的调用）如下面代码：

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;
	d1.Init(2022, 3, 2);
	d1.Print();
	return 0;
}

经典问题：C++中struct和class的区别是什么？

解答：C++需要兼容C语言，所以C++中struct可以当成结构体去使用。另外C++中struct还可以用来定义类且和class定义类是一样的；它们的区别是struct的成员默认访问方式是public，而class是的成员默认访问方式是private。

3、类的封装

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

形象说明：我们如何管理历史文化遗迹呢？如果什么都不管，遗迹就被随意破坏了。那么我们首先建了栅栏将遗迹给封装起来，但是我们目的全封装起来并不是不让别人看，而是为了更好的保护和管理。所以我们开放了售票通道，可以买票突破封装在合理的监管机制下进去参观。类也是一样，我们使用类数据和方法都封装到一下。不想给别人看到的，我们使用private把成员封装起来。开放一些共有的成员函数对成员合理的访问。所以封装本质是一种管理。

4、类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员，需要使用 :: 作用域解析符指明成员属于哪个类域，但在类的作用域内则不用。

Date.h  // 声明

#include<iostream>
using namespace std;

class Date
{
public:
	void Init(int year, int month, int day);

	void Print();

private:
	int _year;
	int _month;
	int _day;
};

Date.cpp  // 定义

#include"Date.h"

void Date::Init(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
}

void Date::Print()
{
	cout << _year << '-' << _month << '-' << _day << endl;
}

5、类的实例化

定义：用类类型创建对象的过程，称为类的实例化。
1）类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。
2）一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量
3）做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

class Date
{
public:
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    Date d1;   // 类的实例化
    return 0;
}

6、类对象的存储方式及大小计算

存储方式 -- 对于类对象的存储是分别存储不同类对象的成员变量，成员函数是存储在一个公共的位置。原因：对于成员变量我们在定义时给定的值是不确定的，所以要单独存储；但是对于成员函数而言在由同一个类定义的对象中是相同的，没有必要再每次对象实例化时都进行存储，因此是存储一份共同使用。（这里图示的话应该会更清楚，但不知道为什么现在优快云上传不了，以后有机会补上吧）

大小的计算 -- 只计算类对象成员变量所占空间的大小，其存储方式与C的结构体内存对齐方式同，这里偷个懒放个链接，有需要自取

（(55条消息) 结构体内存对齐_xxtzzxx的博客-优快云博客_结构体内存对齐）

放个代码仅供参考

class Date
{
public:
	void Init(int year, int month, int day);  // 函数定义这里就不放了

	void Print();

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	cout << sizeof(d1) << endl;
	return 0;
}

最终结果：12 byte（根据结构体内存对齐方式计算）

那么一个空类的大小是多少呢？

答案是： 1 byte （自己试一下）

结论：一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。

7、this 指针

如果我们细心的话就不难发现，类的成员函数中并没有接收实例化对象的形参，这么做的原因是为了简化代码提高效率；试想如果类的成员函数非常多时，如果需要书写接收对象的形参也是非常麻烦的；但是我们没有写并不代表没有，而是说C++中默认有这么一个形参存在，从而省去了我们自己去写。也就是this指针。

this指针特性

1）this指针的类型：类类型* const。
2）只能在“成员函数”的内部使用。
3）this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4）this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

//void Date::Init(const Date* this, int year, int month, int day);
void Date::Init(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;

	//this->_year = year;
	//this->_month = month;
	//this->_day = day;
}

上面代码是this指针实际存在的一个情况，只是编译器帮我们简化了。

最后放一个题目来看看：

// 代码一
class A
{
public:
    void PrintA()
    {
        cout<< _a <<endl;
    }

private:
    int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
} 
// 结果：程序崩溃

class A
{
public:
    void Show()
    {
        cout<<"Show()"<<endl;
    }
private:
    int _a;
};
int main()
{
    A* p = nullptr;
    p->Show();
    return 0;
}
结果：Show()

程序一崩溃的原因是：空地址去访问成员变量，这是万万不行的。

★★★★★ 感谢阅读！