《类和对象》(上篇)

本文主要对类和对象有一个初步的了解。

文章目录

  • 前言
  • 1、类的引入和定义
  • 2、类的访问限定符及封装
    • 2.1 访问限定符
    • 2.2 封装
  • 3 、类的作用域
  • 4 、类的实例化
  • 5 、类对象的模型
    • 5.1 类对象的大小
    • 5.2 类对象存储方式
  • 6、this 指针
    • 6.1 引子
    • 6.2 特性
    • 6.3 this指针的一个问题


前言

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

两种思想的设计方式截然不同,例如设计简单外卖系统:

  • 面向过程:关注实现下单、接单、送餐等过程。体现到代码层面就是函数(方法),总体关注过程
  • 面向对象:关注实现类对象及类对象间的关系。用户,商家,骑手,以及他们之间的关系,提现到代码层面就是类的设计和类之间的关系

C++是基于面向对象的语言:它可以面向过程和面向对象混编,原因是 C++ 兼容 C ;但是对于 java 等纯面向对象语言:只有面向对象 。


1、类的引入和定义

C++ 中定义类有两个关键字 struct/class .
例如:

struct Stu
{
	char name[10];
	int age;
	int id;
};

class cl
{
	char id[10];
	char teacher[8];
	int tage;
};

C++ 兼容 C 中结构体的用法,同时 struct 在 C++ 中也升级成了类 。

在 C 中创建结构体局部变量,需要写成:

struct Stu s1;

但是升级为类之后,Stu 就直接变为类的名称,当定义局部变量时,可以写为 Stu s2 ;但是也可以像上面那么写,因为 C++ 是兼容 C 的。

struct Stu s1; // 兼容 c 
Stu s2; // 升级到类,Stu 为类名,也是类型

同样,对它们进行访问也没问题:
《类和对象》(上篇)_第1张图片
C++中的 struct(类)和结构体不同的是:除了可以定义成员变量(变量)还可以成员函数(函数),成员函数可以访问成员变量,但是如果成员函数中的形参和成员变量相同 ,就像这样:

struct Stu
{
	char name[10];
	int age;
	int id;

	void init(const char* name, int age, int id) {}
};

这样就分不清形参和成员变量,所以C++就会引入 ‘_’ 的定义变量名,以作区分 ;所以通常会写作:

struct Stu
{
	char _name[10];  //成员变量
	int _age;
	int _id;
	
	void init(const char* name, int age, int id) {} //成员函数
};

在接下来讲解之前,我再说明一个点,由于C++是面向对象的,所以一般把定义的变量叫做对象 ,虽然变量也对,但是最好叫对象,之后我也都会这么讲。这时,我们简单写一个类,应用我们学的知识:

class Stu
{

public:  //访问限定符
	void Init(const char* name, int age, int id)
	{
		strcpy(_name, name);
		_age = age;
		_id = id;
	}

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

private://访问限定符
	char _name[10];
	int _age;
	int _id;

};


int main()
{
	Stu s1;

	s1.Init("yaya", 24, 123456);
	s1.Print();
	return 0;
}

《类和对象》(上篇)_第2张图片

2、类的访问限定符及封装

我们刚才写了一个类,但是里面的publicprivate是什么呢?
有人会发现不写这个还会报错!
这其实是c++的访问限定符

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

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

封装的特性:

  1. 在类中,将类的属性和方法放在一起
  2. 访问限定符

访问限定符,可以对 对象 进行 严格管控

2.1 访问限定符

《类和对象》(上篇)_第3张图片
访问限定符特点:

  1. public修饰的成员在类外可以直接被访问
  2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
  3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
  4. 如果后面没有访问限定符,作用域就到 } 即类结束。
  5. class的默认访问权限为private,struct为public(因为struct要兼容C)
  6. 默认访问限定符,即不写时,类中的默认访问权限;一般在定义类时,建议明确定义访问限定符 ,不要用 class/struct的默认限定

访问限定符是约束外面的,对于类中,则没有限定,类里面可以全局访问。
1, 2 点
《类和对象》(上篇)_第4张图片
3, 4 点:
框起来的部分均为 public
《类和对象》(上篇)_第5张图片
5 点:
《类和对象》(上篇)_第6张图片

2.2 封装

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

封装本质上是一种管理,让用户更方便使用类。比如:对于电脑这样一个复杂的设备,提供给用户的就只有开关机键、通过键盘输入,显示器,USB插孔等,让用户和计算机进行交互,完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

对于计算机使用者而言,不用关心内部核心部件,比如主板上线路是如何布局的,CPU内部是如何设计的等,用户只需要知道,怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时,在外部套上壳子,将内部实现细节隐藏起来,仅仅对外提供开关机、鼠标以及键盘插孔等,让用户可以与计算机进行交互即可

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

由此,我们总结一下,封装就是:

  • 数据和方法都封装到类里
  • 能访问定义成共有;不能访问定义成私有

好的,我给你用,不好的,直接锁死,不让你访问,这就是封装的好处 ,严格管控了。

3 、类的作用域

先举个例子,假设写一个栈,写两个文件:
Stack.h :

#pragma once

class Stack
{
public:
	void Init();
	void push(int x);
	// ... 
private:
	int* _a;
	int capacity;
	int _top;
};

Stack.cpp :
《类和对象》(上篇)_第7张图片
当跨文件访问时,报错了。这是因为类是由作用域的**,类定义了一个新的作用域,类的所有成员都在类的作用域中。**

在类体外定义成员时,需要使用::作用域操作符指明成员属于哪个类域
《类和对象》(上篇)_第8张图片

4 、类的实例化

用类类型创建对象的过程,称为类的实例化

  1. 类是对对象进行描述的,是一个模型一样的东西,限定了类有哪些成员,定义出一个类并没有分配实际的内存空间来存储它

    比如:入学时填写的学生信息表,表格就可以看成是一个类,来描述具体学生信息。

  2. 一个类可以实例化出多个对象,实例化出的对象 占用实际的物理空间,存储类成员变量

就好比类是图纸,根据图纸可以建造出楼房,四栋都不是问题
《类和对象》(上篇)_第9张图片
但是对于类本身是图纸,图纸并不能住人;房子才能住人。
所以对于类创建出来的对象,可以访问类中成员;但是对于类本身,是不能访问成员与方法的:
《类和对象》(上篇)_第10张图片

所以对于类仅仅起 描述作用 而已,真正使用还是要类对象 。而我们可以认为类这些代码存在代码段,是公共的。

5 、类对象的模型

5.1 类对象的大小

注:计算类或类对象的大小,只看成员变量,并考虑内存对齐,C++内存对齐规则跟 C 结构体一致
对于类对象的大小,该如何计算?

class Stack
{
public:
	void Init();
	void push(int x);
	// ... 
private:
	int* _a;
	int _capacity;
	int _top;
};

打印看看:
《类和对象》(上篇)_第11张图片
那么对象中存了成员变量,是否存了成员函数呢? 答案是没存成员函数。如何理解?先修改代码(将 Stack 都变为公有),便于测试:

class Stack
{
public:
	void Init();
	void push(int x);
	// ... 

	int* _a;
	int _capacity;
	int _top;
};

对于两个不同的类对象,各自具有独立的空间,具有独立的成员变量:
《类和对象》(上篇)_第12张图片
但是调用成员函数只有一份。

5.2 类对象存储方式

那么为什么不包含成员函数?看下方成员变量和成员函数都存储的设计方式:
《类和对象》(上篇)_第13张图片
每个对象中成员变量是不同的但是调用同一份函数,如果按照此种方式存储,当一个类创建多个对象时,每个对象中都会保存一份代码,相同代码保存多次,浪费空间

但是如果采用以下设计方法,就可以减少对空间的消耗:
《类和对象》(上篇)_第14张图片
对于类中成员变量,独立保存起来;但是类中成员函数就和普通的函数一样存在于公共代码区,即代码段,也就是常量字符串存储地,这里存在代码段的含义就是:函数被编译后的指令存在于代码段

对于如何计算类的大小有几点:

  1. 类中只计算成员变量的大小,计算方式满足C语言结构体内存对齐
  2. 空类和只具有成员函数的类大小为 1

结构体内存对齐规则

  1. 第一个成员在与结构体偏移量为0的地址处。
  2. 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
    注意:对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
    VS中默认的对齐数为8
  3. 结构体总大小为:最大对齐数(所有变量类型最大者与默认对齐参数取最小)的整数倍。
  4. 如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整
    体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍

第 2 点说明:

对于空类和只有成员函数的类也有自己的地址,并不是空,所以一定有大小,编译器给了空类 1 字节来唯一标识空类(当然也有类的大小也为1,具体看实现):
《类和对象》(上篇)_第15张图片

这 1 字节是为了占位,并不存储有效数据,标识对象被实例化定义了,表示存在 。

总结:计算类或类对象的大小,只看成员变量,并考虑内存对齐,C++内存对齐规则跟 C 结构体一致

6、this 指针

对于之后的学习,我们将围绕日期类和栈类,来对类和对象更好地理解,所以我们先写出一个日期类:

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;
};

6.1 引子

我们先看一个问题,之前说过类中成员变量命名风格最好加上 ‘_’ ,以示区分;但如果不加区分,对于成员函数中访问的变量访问那个?

测试一下:
《类和对象》(上篇)_第16张图片
对于成员函数中的 year 的值是 2023 ,而日期对象 s 的 year 为随机值;说明如果发生这种情况,成员函数访问形参,遵守局部优先原则。(右边的year)

那如何让成员函数访问成员变量的 year ?,可以使用域作用限定符 ::
《类和对象》(上篇)_第17张图片

但是尽量不要这么写,其一是因为容易误导,其二是小题大做,明明只有命名风格的事情,又上升到语法了。

回到主线,我们继续测试日期类:

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(2023, 1, 31);
	d1.Print();

	Date d2;
	d2.Init(2023, 2, 1);
	d2.Print();

	return 0;
}

此刻执行程序:
在这里插入图片描述
上面讲过 类的实例化 后,我们知道类实例化处的每个对象是独立的,所以对象的成员变量是独立的,但是多个类对象都使用共同的成员函数 :
《类和对象》(上篇)_第18张图片
看到 call 指令这一行,发现函数的地址是相同的,也印证了我们的说法:不同对象使用相同成员函数。

6.2 特性

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

但是有个问题,就拿 Print 函数来说,当 d1 调用 Print 函数时,打印的是 d1 的成员变量;当 d2 调用时,打印的是 d2 的成员变量。而类对象中的成员变量是独立的,如何做到每次调用都可以输出正确的成员变量的?

这就依靠的是 this 指针 :
对于 d1._year ,即对象访问成员变量,意义是在类对象这块空间中,访问到 _year 这个成员变量,对其进行操作:
《类和对象》(上篇)_第19张图片
而对于 d1.Print() ,则是访问成员函数,是到公共区域代码段上找到成员函数,找到变为 call 指令,进行调用,这里有两层,第一层就是我们前面说的;第二层就是 this 指针。

当代码被编译之后,编译器会对成员函数进行处理,例如这里的 Print 函数,就有一个隐藏的 this 指针 ,类似:

void Print(Date* const this) // const 是因为 this 指针不可改,this 是指针,所以直接用 const 修饰 this 
{
    cout << this->year << "-" << this->_month << "-" << this->_day << endl;
}

// 调用 
d1.Print(&d1);

大约就是这么处理的。当不同的对象调用时,根据传过来的地址,this 指针会指向不同的对象。同理,对于 Init 函数也是这样,我就不多赘述了。

但是注意一点,虽然道理是这样,但是我们不能这么写,例如 d1.Print(&d1) 就会报错,因为 this 指针是隐藏的,统一规定就别写,由此提炼出两点:

  1. 调用成员函数时,不能显示传实参给 this
  2. 定义成员函数时也不能声明形参 this

即形参和实参不能写,但是在成员函数中,是可以显示写的,但是很少用:

cout << this->year << "-" << this->_month << "-" << this->_day << endl;

甚至打印 this 指针也是可以的:

void Print(Date* const this) // const 是因为 this 指针不可该,this 是指针,所以直接用 const 修饰 this 
{
    cout << this << endl;
    cout << this->year << "-" << this->_month << "-" << this->_day << endl;
}

这里打印的 this 指针的地址,就是对应对象的地址:
《类和对象》(上篇)_第20张图片

this 指针在哪里?

一般情况下在栈区,因为 this 指针是隐含的形参,this 指针并不在对象中 。而 this 指针不需要处理,一般会直接转换为指令,我们不用担心。

但是有时也会特殊处理:
《类和对象》(上篇)_第21张图片
在 vs 下,有些情况会将对象的地址(即 this 指针)放到寄存器 ecx 中,因为在调用成员函数时 this 指针要被经常使用(this->_year)。

6.3 this指针的一个问题

接下来,通过这几个题目看看你对于类的理解吧!
q1:

// 1.下面程序编译运行结果是? A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void PrintA()
	{
		cout << "Print()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

q2 :

// 1.下面程序编译运行结果是? A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}

q3:

// 1.下面程序编译运行结果是? A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void PrintA()
	{
		cout << "PrintA()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	(*p).PrintA();
	return 0;
}

// 1.下面程序编译运行结果是? A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void PrintA()
	{
		cout << "PrintA()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	(*p).PrintA();
	return 0;
}

答案揭晓:
q1 :C 正常运行
《类和对象》(上篇)_第22张图片
q2:B 运行奔溃
《类和对象》(上篇)_第23张图片
q3:C 正常运行
《类和对象》(上篇)_第24张图片
分析:
q1分析:

1:PrintA() 是成员函数,成员函数在代码段,在公共区域;虽然 p 是空指针,但是访问公共区域并不会报错,因为我不需要到对象里面找。
2:而调用函数,会把 p 当做 this 指针传过去,在 PrintA() 函数中,并没有解引用,所以没有问题,只不过此刻的 this 指针为空而已。

提一个注意点 :

这里可以定义变量访问 PrintA 函数,也可以用指针,例如 d.PrintA() 和 p->PrintA() 都是可以的;但是千万不要写成 PrintA(); 的形式,因为类是有作用域的,在调用函数时,只会默认在全局找,得规定在哪个类中,二是因为 this 指针的问题,因为此刻没有对象,this 指针也不清楚,所以这样是错误的.

q2 分析:

同理 PrintA() 在公共区域,所以调用时是没有问题的,问题在于当 this 指针传递过去后,函数中是这样的:cout << _a << endl; 这里实际上为 cout << this->_a << endl ,对空指针进行了解引用,这就崩溃了。

q3 分析:

PrintA() 是公共的,不在对象里面;这里表面上看(*p).PrintA()是对空指针进行解引用了,其实并没有,编译器对其进行了处理,这里是把 p 传递给了 this ,而这里本质上和p->PrintA()是相同的,我们看一下汇编代码:
在这里插入图片描述
这里的崩溃与否取决于访问的东西是否在对象中,如果访问的是公共区域,那么就再看传递的 this 指针为空指针时,会不会对 对象 进行解引用。

引用:http://t.csdn.cn/79a4t

你可能感兴趣的:(c++修炼之路,c++,算法,开发语言)