类与对象(上)

@@永恒

已于 2023-02-07 20:30:07 修改

阅读量501

点赞数 5

分类专栏：【和伙伴一起学C++】文章标签： c++

于 2022-05-24 16:46:25 首次发布

本文链接：https://blog.csdn.net/qq_53010164/article/details/124925186

版权

【和伙伴一起学C++】专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、面向过程与面向对象的初步认识

C语言是面向过程,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。
当设计比如简单的外卖系统,面向过程关注的主要是下单、接单、送餐这些过程。体现到代码层面主要是方法或者函数。

C++是基于面向对象的，关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完成。
当设计比如简单的外卖系统时，面向对象关注的是实现类对象及类对象间的关系,用户、商家、骑手以及他们之间的关系。体现到代码层面主要是类的设计及类之间的关系。

C++虽然说是面向对象的，但是因为兼容C，所以也可以说是面向过程和面向对象混编。

而比如说JAVA就是纯面向对象的语言。

二、类的引入

在C语言中struct 定义的是结构体,而在C++中，不仅兼容C里面的结构体的用法，并且同时struct在C++中也升级成了类

struct Student
{
	char name[20];
	int age;
	int id;
};
int main()
{
	struct Student s1;//C语言的结构体创建方式，c++兼容C，也可以用这种方式创建
	Student s2;//升级到类,Student为类名,也是类型
	
	strcpy(s1.name,"张三");//是字符串数组,字符串拷贝
	s1.age = 10;
	s1.id = 1;

	strcpy(s2.name,"里斯");//类的赋值和结构体的赋值没有什么差别
	s2.age = 12;
	s2.id = 2;
}

运行结果如下:

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

struct Student
{
	//成员变量
	char _name[20];//为了与函数中的形参相区别,所以加"_"
	int _age;
	int _id;
	//成员方法/成员函数
	void Init(const char* name,int age,int id)
	{
		strcpy(_name,name);
		_age = age;
		_id = id;
	}
	void print()
	{
		cout << _name << endl;
		cout << _age << endl;
		cout << _id << endl;
	}
};
int main()
{
	struct Student s1;//C语言的结构体创建方式，c++兼容C，也可以用这种方式创建
	Student s2;//升级到类,Student为类名,也是类型
	s1.Init("张三",10,1);
	s2.Init("里斯", 12, 2);
	s1.print();
	s2.print();
}

结果运行如下：

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

3.1 访问限定符

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

所谓访问权限，就是能不能使用该类中的成员。

一般地，在类的内部，无论成员被声明为哪种，都是可以互相访问的；但在类的外部，如通过类的对象，则只能访问 public 属性的成员，不能访问protected、private属性的成员。

访问限定符分为三种:public(公有)、protected(保护)、private(私有)

访问限定符说明:

1. public 修饰的成员在类外可以直接被访问

2. protected 和 private 修饰的成员在类外不能直接被访问 ( 此处 protected 和 private 是类似的 )

3. 访问权限 作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

4. class的默认访问权限为private，struct为public(因为struct要兼容C)

5.一般在定义类的时候,建议明确定义访问限定符,不要class/struct默认限定

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

class Student
{
	//成员变量
	char _name[20];//为了与函数中的形参相区别,所以加"_"
	int _age;
	int _id;
	
	//成员方法/成员函数
	 void Init(const char* name, int age, int id)
	{
		strcpy(_name, name);
		_age = age;
		_id = id;
	}
	void print()
	{
		cout << _name << endl;
		cout << _age << endl;
		cout << _id << endl;
	}
};
int main()
{
	struct Student s1;//C语言的结构体创建方式，c++兼容C，也可以用这种方式创建
	Student s2;//升级到类,Student为类名,也是类型
	s1.Init("张三", 10, 1);
	s2.Init("里斯", 12, 2);
	s1.print();
	s2.print();
}

将struct变为class运行后,运行的代码是有问题的，如上图,无法访问到Init和print，是因为class的默认访问权限是private,而为什么struct却没有问题呢？因为struct的默认访问权限是public,所以处理的方法就是给Init和private加上public的访问权限.

正确的代码如下图:

class Student
{
//成员变量此时也是默认为私有
	//成员变量
	char _name[20];//为了与函数中的形参相区别,所以加"_"
	int _age;
	int _id;
public:	
	//成员方法/成员函数
	 void Init(const char* name, int age, int id)
	{
		strcpy(_name, name);
		_age = age;
		_id = id;
	}
	void print()
	{
		cout << _name << endl;
		cout << _age << endl;
		cout << _id << endl;
	}
};
int main()
{
	struct Student s1;//C语言的结构体创建方式，c++兼容C，也可以用这种方式创建
	Student s2;//升级到类,Student为类名,也是类型
	s1.Init("张三", 10, 1);
	s2.Init("里斯", 12, 2);
	s1.print();
	s2.print();
}

运行结果如下:

3.2 定义顺序与调用顺序问题

	class Stack
	{
	public:
		void Init()
		{
			_a = nullptr;//成员变量在类中可以直接访问
			_top = _capacity = 0;
		}
	private:
		int* _a;//成员变量
		int _top;
		int _capacity;
	};
	
	int main()
	{
		Stack st;
		st.Init();
		return 0;
	}

类成员变量、成员函数的定义顺序与调用顺序无关,如果函数A定义在函数B的后面，但是在函数B也可以直接调用函数A。因为编译器分两步处理类：首先编译成员的声明,然后再编译函数体（如果有的话）。（引用于:https://www.cnblogs.com/AKUN-FYK/p/10977948.html）

四、类的作用域

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

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

五、类对象模型

5.1如何计算类的大小

// 类中既有成员变量，又有成员函数
class A1 {
public:
	void f1() {}
private:
	int _a;
};
// 类中仅有成员函数
class A2 {
public:
	void f2() {}
};
// 类中什么都没有---空类
class A3
{};
int main()
{
	A1 a1;
	A2 a2;
	A3 a3;
	cout << sizeof(a1) << endl;//4B,对象中存了成员变量，但是没有存储成员函数
	
	//空类会给1B，这1B不存储有效数据，只是为了占位,表示对象存在
	cout << sizeof(a2) << endl;//1B
	cout << sizeof(a3) << endl;//1B
}

结论：
①一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类，表示这个类的对象存在
②只保存成员变量，成员函数存放在公共的代码段

5.2 结构体内存对齐规则

可以参考自定义类型：结构体，枚举，联合_迷茫中的小伙的博客-CSDN博客

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

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

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

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

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

六、类的实例化

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

1. 类只是 一个模型一样的东西，限定了类有哪些成员，定义出一个类 并没有分配实际的内存空间 来存储它

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

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

七、this指针

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

int main()
{
	Date d1;
	d1.Init(2022,5,24);
	d1.print();
	return 0;
}

首先我们先定义一个日期类,那么问题来了,Date类中有Init与print两个成员函数，函数体中没有关于不同对象的区分，那当d1调用Init函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？原因如下:

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

上面的代码通过编译器操作之后的代码应如下面注释中的代码:

class Date
{
public:
	void Init(int year, int month, int day)//void Init(Date* this,int year, int month, int day)
		
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()//void print(Date* this)
	{
		cout << _year << "-" << _month << "-" << _day << endl;
		//cout << this->_year << "-" <<this-> _month << "-" <<this-> _day << endl;可以这样写，但没必要
	}
	
	//上面的代码可以处理为如下代码
	//this应该是编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数,自己不应该加上(此处是为了了解编译器的操作加上的)
	/*void Init(Date* const this, int year, int month, int day)//this指针本身不能被改变
	{
		this->_year = year;//在使用成员函数时可以加上this,但是有时没有必要,因为不加会更方便
		this->_month = month;
		this->_day = day;
	}
	void print(Date* const this)
	{
		cout << this->_year << "-" <<this-> _month << "-" <<this-> _day << endl;
	}*/

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

int main()
{
	Date d1;
	Date d2;
	//此处也不可以加上&d1,&d2,这是编译器的操作(此处只是为了了解编译器的操作)
	d1.Init(2022, 5, 24);//d1.Init(&d1,2022,5,24);
	d1.print();//d1.print(&d1);

	d2.Init(2022, 5, 24);//d2.Init(&d2,2022,5,24);
	d2.print();//d2.print(&d2);

	return 0;
}

总结:

1.调用成员函数时,不能显示传实参给this(不能自己将&d1传给函数中的Date* this),因为这是编译器隐藏的操作

2.定义成员函数时,也不能显示形参this

3.在成员函数内部,可以显示使用this,但有时不写更方便(编译器只会在类的成员变量前面加this)

4. this指针的类型：类类型* const

5. this 指针本质上其实是一个成员函数的形参 ，是对象调用成员函数时，将对象地址作为实参传递给 this 形参。所以对象中不存储this指针 。

6. this 指针是成员函数第一个隐含的指针形参，一般情况由编译器通过 ecx 寄存器自动传递，不需要用户 传递，有时也存储在栈中。

7.2 牛刀小试

下面的程序的运行结果是？

A 编译报错 B. 运行崩溃 C.正常运行
//代码1：
class A
{ 
public:
 void PrintA() //A* const this
 {
 cout<<_a<<endl;//this->_a,此处解引用了空指针this
 }
private:
 int _a;
};
int main()
{
 A* p = nullptr;
 p->PrintA(); 
}
//代码2:
class A
{ 
public:
void Show()//A* const this
 {
 cout<<"Show()"<<endl;//此处没有解引用空指针this,所以运行正常
 }
private:
 int _a;
};
int main()
{
 A* p = nullptr;
 p->Show; 
}
解析:

1.指针p虽然是空指针,但是p调用成员函数并不会导致编译错误,因为编译只要检查的是语法错误，所以代码1，代码2排除编译错误。
2.指针p虽然是空指针,但是因为成员函数并没有存放在对象里面而是放在公共代码段中,所以p调用成员函数不会出现空指针访问的问题,所以代码2是正常运行。
3.代码1、代码2都会把指针p作为实参传递给隐藏的this指针,但是代码2并没有用解引用this,所以是没有问题的(正常运行),但是代码1却解引用了this(空指针),最后导致运行崩溃的问题。