C++类与对象初阶引用 | 类封装 | 类对象模型 | this指针

NO.-LL

已于 2022-08-16 17:05:18 修改

阅读量309

点赞数 25

分类专栏： C++学习路程文章标签： c++ 开发语言

于 2022-06-18 19:59:46 首次发布

本文链接：https://blog.csdn.net/qq_61386381/article/details/124989492

版权

C++学习路程专栏收录该内容

12 篇文章 14 订阅

订阅专栏

前言：

C语言是面向过程的，关注的是过程（函数），分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象（类），将一件事情拆分成不同的对象，靠对象之间的交互完成。

简单来说，由类定义出来的变量叫做对象，只不过C语言中更愿意叫做变量，C++中把它称作对象

强烈建议先看：C++入门基础总结（最详细）_NO.-LL的博客-CSDN博客

类的引入与定义

类的引入

C语言中，结构体中只能定义变量。在C++中，结构体内不仅可以定义变量，也可以定义函数，同时结构体的名称可以做类型。（在C++中struct 被升级成了类）

struct Student
{
	void SetStudentInfo(const char* name, const char* gender, int age)
	{
		strcpy(_name, name);
		strcpy(_gender, gender);
		_age = age;
	}

	void PrintStudentInfo()
	{
		cout << _name << " " << _gender << " " << _age << endl;
	}
	char _name[20];//_用来标识成员变量，同时可以区分成员变量和形参
	char _gender[3];
	int _age;
};
int main()
{
	Student s;//结构体的名称做类型
	s.SetStudentInfo("张三", "男", 20);
    s.PrintStudentInfo();
	return 0;
}

以上struct student就是一个类，student就是一个类名。

（上面结构体的定义，在C++中更喜欢用class来代替）

注意：C++中struct被升级成类，类是一个整体，比如上面的函数SetStudentInfo()中使用到了_name，虽然类中的_name在后面，但是在SetStudentInfo()函数中也是可以使用的。

类的定义

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

}; // 一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号。

类中的元素称为类的成员；

类中的数据称为类的属性或者成员变量;

类中的函数称为类的方法或者成员函数；

类的两种定义方式：

1.声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理（一般较短的函数会在类内定义）。

class student//学生类
{
public:
    //显示学生基本信息
	void showInfo()
	{
		···
	}
public:
	char* _name;//学生的姓名
	int _age;//学生的年龄
};

成员函数如果在类中定义，编译器可能会将它当作内联函数来处理。

注意，是可能。并不是说一定会成为内联函数，之前讲内联函数的时候我们也说了。

内联函数对编译器来说也只是一个建议。至于到底会不会成为内联是由编译器来决定的。

取决于编译器看这个函数符不符合条件，一般一个函数太长（大概是十几行左右），或者函数是一个递归，编译器就不会让它成为内联了。

2.函数声明放在类内，函数放在类外

class student
{
public:
    void printInfo();
public:
    int age;
    char *name;
}

void student :: printInfo()
{
    ......
}

一般情况下我们会采用第二种方式。但是这就会涉及友元和类的作用域，一两句话很难概括，请听我徐徐道来~~

类的访问限定符及封装

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

在类和对象阶段，我们只研究类的封装特性，那什么是封装呢？

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

把数据都封装到类里面。
可以给你访问定义成公有，不想给你访问的定义成私有或者保护。

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

访问限定符有三种：

public（公有）
protected（保护）
private（私有）

【访问限定符说明】

public修饰的成员在类外可以直接被访问
protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的) ，但是在类内可以直接被访问
访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
class的默认访问权限为private（我们也可以手动去加），struct为public(因为struct要兼容C)

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

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

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

类的作用域和实例化

类的作用域

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

class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout << _name << " "_gender << " " << _age << endl;//_name和_gender都是类里面的
}

类的实例化

首先要说清楚的是：类本身是没有存储空间的。

通过类建立出对象，即实例化，才会有实际的存储空间

我们把用类类型创建对象的过程称为 —— 类的实例化。

类只是一个像 "图纸" 一样的东西，限定了类有哪些成员。定义出一个类，并没有分配实际的内存空间来存储它。
一个类可以实例化出多个对象，占用实际的物理空间，存储类成员的变量。

做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

（资料来源：比特科技）

类对象模型

类的存储大小

存储方式为：只保存成员变量，成员函数存放在公共的代码段

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

// 类中既有成员变量，又有成员函数
class A1 {
public:
	void f1() {}
private:
	int _a;
};
 
// 类中仅有成员函数
class A2 {
public:
	void f2() {}
};
 
// 类中什么都没有 - 空类
class A3
{};

sizeof（A1）： 4

sizeof（A2）： 1

sizeof（A3）： 1

还需要考虑一下，静态的成员变量，静态成员变量在静态区，属于所有类共享，不属于单独类，因此静态成员变量不在类中，不需要计算它的大小。

不同空类定义的对象，它们的地址肯定是需要不一样的，因此给1字节是为了占位，起标识作用。

注意：空的类，即像下面这样的类，也会在内存中占据一个字节：
class A
{};
问：为什么一定要在内存中占据一个字节呢？

答：因为定义变量的时候总要在内存中占据一个地址空间的，用来标识变量的存在。

总结：类的大小只需要考虑非静态的成员变量。成员函数和静态成员变量都是共享一份空类比较特殊，编译器给了空类一个字节来唯一标识这个类。

内存对齐规则

类大小的计算，需要考虑内存对齐。

结构体的对齐规则：

结构体的第一个成员放在结构体变量在内存中存储位置的0偏移处开始。
从第2个成员往后的所有成员，都要放在一个对齐数（成员的大小和默认对齐数的较小值）的整数的整数倍的地址处。VS 中默认对齐数为8！
结构体的总大小是结构体的所有成员的对齐数中最大的那个对齐数的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

类与结构体内存对齐规则相同

this指针

this指针的引出

为了能够更好地讲解，我们首先来定义一个日期类 Date：

#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(void)
{
	Date d1;
	d1.Init(2022, 3, 7);
	d1.Print();
 
	Date d2;
	d2.Init(2022, 5, 20);
	d2.Print();
 
	return 0;
}

对于上述类，有这样的一个问题：

Date类中有Init与Print两个成员函数，函数体中没有关于不同对象的区分，那当s1调用Init函数时，该函数是如何知道应该设置s1对象，而不是设置s2对象呢？当s1调用Print函数时，该函数是如何知道打印的是s1对象而不是s2对象呢？

答：C++ 通过引入 this 指针解决该问题。

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

注释的是隐藏前的内容，如下：

#include <iostream>
using namespace std;
 
 class Date {
public:
	// void Init(Date* const this, int year, int month, int day)
	void Init(int year, int month, int day) {
		_year = year;
		_month = month;
		_day = day;
        //this->_year = year;
		//this->_month = month;
		//this->_day = day;
	}
 
	// void Print(Date* const this)
	void Print() {
		cout << _year << "-" << _month << "-" << _day << endl;
		// cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	}
 

private:
	int _year;
	int _month;
	int _day;
};
 
int main(void)
{
	Date d1;
	d1.Init(2022, 3, 7);    // d1.Init(&d1, 2022, 3, 7);
	d1.Print();             // d1.Print(&d1);
 
	Date d2;
	d2.Init(2022, 5, 20);   // d2.Init(&d2, 2022, 5, 20);
	d2.Print();             // d2.Print(&d2);
 
	return 0;
}

this指针的特性与使用细则

this指针的类型：类类型 const*
只能在“成员函数”的内部使用
this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
**this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递，如果用户强制传递，那么编译器会报错，当然，我们可以在成员函数中使用this指针但是不能对this指针的指向进行修改（当然，我们可以通过一些其它的方法进行修改，此处的不可修改是不可显式的进行修改），**即this是一个指针常量，但是不能在参数（实参和形参中均不可）中写this指针。
this指针式编译器默认加上的，无论在我们的成员函数内是否用的到，即使你的函数内容为空

使用细则

1.调用成员函数时，不能 "显示地" 传实参给 this ：

2.定义成员函数时，也不能 "显示地" 声明形参 this ：

void Print(Date* const this)//错误
{
	cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
}

void Init(Date* const this,int year, int month, int day)//错误
{
	this->_year = year;
	this->_month = month;
	this->_day = day;
}
d1.Init(&d1, 2022, 5, 12);    //以下都是错误写法
d2.Init(&d2, 2022, 5, 12);
d1.Print(&d1);
d2.Print(&d2);

3.但是，在成员函数内部，我们可以 "显示地" 使用 this ：

class Date
{
public:
	void Print()    //正确写法
	{
		cout << this -> _year << "-" << this -> _month << "-" << this -> _day << endl;
	}
	void Init(int year, int month, int day)
	{
		this -> _year = year;
		this -> _month = month;
		this -> _day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

（笔记篇：资料来源 - 比特科技）

NO.-LL

关注

25
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
28
评论
C++类与对象初阶引用 | 类封装 | 类对象模型 | this指针

成员函数如果在类中定义，编译器可能会将它当作内联函数来处理。注意，是可能。并不是说一定会成为内联函数，之前讲内联函数的时候我们也说了。内联函数对编译器来说也只是一个建议。至于到底会不会成为内联是由编译器来决定的。这也不取决于编译器心情，心情好就让你成为内联，心情差就不让……而是！取决于编译器看这个函数符不符合条件，一般一个函数太长（大概是十几行左右），或者函数是一个递归，编译器就不会让它成为内联了。类的作用域类定义了一个新的作用域，类的所有成员都在类的作用域中。在类外定义成员
复制链接

扫一扫