C++类与对象【初识】

面向对象是什么？

  概念： 面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

什么玩意？？我还是不明白呀！！不要急，我们现在就来搞明白。
  在了解面向对象之前先来了解一下什么是面向过程。
  ✨面向过程：C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
  假如我们现在要做一个洗衣服的工作用面向过程的方式来思考我们要做以下步骤：
1.拿盆 2.放水 3.放衣服 4.放洗衣粉 5.洗衣服 6.拧干 7.晾衣服
这里的每一步都需要一个函数来实现。
  再转过头来看看面向对象是怎么实现的。
  ✨面向对象：C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
  还是洗衣服。
  总共有四个对象:人，衣服，洗衣粉，洗衣机。
  整个洗衣服的过程:人将衣服放进洗衣机、倒入洗衣粉，启动洗衣机，洗衣机就会完成洗衣过程并且甩干。
  整个过程主要是:人、衣服、洗衣粉、洗衣机四个对象之间交互完成的，人不需要关心新洗衣机具体是如何洗衣服的，是如何甩干的。
  现在我们就来看一看如何用面向对象的方式来实现洗衣服。

class Clothes //衣服类
{
public:
	Clothes(const char* brand = "HL")
	{
		_brand = brand;
	}
	void Use()
	{
		cout << "衣服是用来穿戴的" << endl;
	}
 //private:
	const char* _brand;//品牌
};



class Detergent //洗衣粉类
{
public:
	Detergent(const char* brand="LiBai")
	{
		_brand = brand;
	}
	void Function() 
	{
		cout << _brand<<"洗衣粉被加入了洗衣机" << endl;
	}
private:
	const char* _brand;
};



class WashingMachine//洗衣机类
{
public:
	WashingMachine(const char* brand = "Haier")
	{
		_brand = brand;
	}
	void Run()
	{
		cout << _brand<<"洗衣机正在洗衣服" << endl;
		cout << _brand << "洗衣机正在烘干" << endl;
	}
private:
	const char* _brand;
};


class People //人类
{
public:
	People(int age=20,const char* sex="man", const char* name="lisi")
	{
		_age = age;
		_sex = sex;
		_name = name;
	}
	void Add(Detergent de)
	{
		de.Function();
	}
	void Add(Clothes cl) 
	{
		cout << _name << "把"<<cl._brand<<"品牌的衣服放进了洗衣机" << endl;

	}
	void Add()
	{
		cout <<_name<< "把脏衣服放进了洗衣机" << endl;
		cout <<_name<<"把水加进了洗衣机" << endl;
	}
	void UseWashingMachine(WashingMachine wm) 
	{
		cout << "我打开了洗衣机开关" << endl;
		wm.Run();
	}
private:
	int _age;
	const char* _sex;
	const char* _name;
};

  这四个类各自独立，然后依靠这些类的功能来实现洗衣服的任务。整个过程的重点是交互完成任务。
  我们来调用一下函数

void Func1() 
{
	People p(18, "woman", "xiaohong");
	WashingMachine wm("Haier");
	Detergent de("LiBai");
	Clothes cl;
	p.Add();
	p.Add(cl);
	p.Add(de);
	p.UseWashingMachine(wm);
}
void Func2() 
{
	People p1(18, "man", "wangwu");
	WashingMachine wm1("SIMENS");
	Detergent de1("BuleMoon");
	Clothes cl1("HXEK");
	p1.Add();
	p1.Add(cl1);
	p1.Add(de1);
	p1.UseWashingMachine(wm1);
}

int main()
{
	cout <<"小红家洗衣服" << endl;
	Func1();
	cout << endl;
	cout << "王五家洗衣服" << endl;
	Func2();
	return 0;
}

  有可能作为初学者的你看不懂上述代码，但我们能看懂这个现象现在就够了。
  ✨总而言之，面向对象就是利用类实例化对象然后通过各个对象之间的交互完成任务的。

---

类的引入

  C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。
  ✨C++语言兼容C语言struct的所有用法，struct同时升级为类，类名就是类型，不需要再加struct定义一个变量（在C++中叫对象），类里可以定义函数

#include
using namespace std;
struct Struct
{   
	void Printf() 
	{
		cout << _a <<" "
			<< _b <<" "
			<< _c << endl;
	}
	int _a = 10;
	int _b = 20;
	int _c = 30;
};
int main() 
{   
	Struct L;
	L._a = 100;
	L.Printf();
	return 0;
}

运行结果
上述结构体定义，在C++中建议用class代替。

---

类的定义

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

};//注意后面的分号

  class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。
  类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。
  类的两种定义方式：
  ✨1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。（声明与定义不分离）

class Person 
{
public:
	void ShowInof() 
	{
		cout << _name << " "
			<< _sex << " "
			<< _age << endl;
	}
private:
	int _age;
	char* _sex;
	char* _name;
};

  ✨2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::（声明与定义分离）

//person.h
#pragma once
#include
using namespace std;
class Person 
{
public:
	void ShowInof();
private:
	int _age;
	char* _sex;
	char* _name;
};


//person.cpp
#include"person.h"
void Person::ShowInof() 
{
	cout << _name << " "
		<< _sex << " "
		<< _age << endl;
}

---

类的访问限定符及封装

 ⭐️访问限定符

  ✨C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
  ✨C++有三种访问控制修饰符
1.public（公有访问控制修饰符）
  public成员可以被其所属的类内部和外部代码访问。
2.private(私有访问修饰符)
  private成员只能在其所属的类内部访问，对外部是不可见的。
3.protected(受保护访问修饰符)
  protected成员可以在其所属的类内部访问，也可以在派生类内部访问。
  ✨访问修饰符使用细节
  1. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。
  2. 如果后面没有访问限定符，作用域就到 } 即类结束。
  3. class的默认访问权限为private，struct为public(因为struct要兼容C)

 ⭐️封装

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

  举个例子，我们的电脑有主机，显示屏，键盘，鼠标，这里的每一个部件都是一个“对象”，我们不知道“对象”的内部细节，但是这些对象提供给了我们可以操作的“接口”，我们可以通过接口和“对象”交互，但是对于主机来讲，它内部有CPU，硬盘，显卡，内存条，我们用户在操作电脑的过程中根本不需要注意这些，也不可能跳过接口直接访问cpu，显卡。这就是封装。

  对于初学者的我们可能现阶段根本理解不了什么是面向对象，什么是封装，这些概念性的东西都只有我们在以后学习的过程中慢慢体会才能明白其到底是什么。

---

类的作用域

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

#include
using namespace std;
class Person 
{
public:
	void ShowInof();
private:
	int _age;
	char *_name;
	char *_sex;
};
void Person::ShowInof() 
{
	cout << _age << " "
		<< _name << " "
		<< _sex << endl;
}

注意：类所有的声明必须声明在类体内，类不存在像命名空间那样合并空间的现象，定义两个同名类属于重定义。

类的实例化

  ✨用类类型创建对象的过程，称为类的实例化
  类是对对象的描述，对象是类的具体表现，对类的实例化就是开辟存储空间存储数据的过程。
  一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。

---

类的对象模型

  猜一下下面这个类的大小是多少

class Person 
{
public:
	void ShowInof()
	{
		cout << _age << " "
			<< _name << " "
			<< _sex << endl;
	}
	int _age;
	const char *_name;
	const char *_sex;
};

  使用sizeof关键词测一下
  64位机下指针大小是8字节
  为什么呀？类内不是还有成员函数吗？不需要将成员函数大小一并算进类的大小中吗？
  这就要考虑计算机是按照什么方式来存储的了。
  ✨对于对象来说成员变量是不同的，但是不同的对象调用的成员函数却是相同的，成员函数存储在公共代码区，这种设计思路大大节约了存储空间。
  所以计算类的大小和计算结构体大小所用方法一样，只需计算成员变量之和
  注意空类大小，对于空类编译器会给空类一个字节来唯一标识这个类的对象。

结构体内存对齐规则

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

---

this指针

定义一个日期类

#include
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()
{
	Date d1, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	d1.Print();
	d2.Print();
	return 0;
}

对于上述类，有这样的一个问题：
  Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？
  C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
所以上述Date类的成员函数其实是这样的

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

传参是这样的

d1.Print(&d1);
d2.Print(&d2);

这些工作是编译器来完成的，我们不能显示的写形参和实参
  ✨this指针的特性
1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
2. 只能在“成员函数”的内部使用
3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this指针是“成员函数”第一个隐含的指针形参（成员函数的第一个参数），一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。
本章结束
考虑一千次，不如去做一次；犹豫一万次，不如实践一次；华丽的跌倒，胜过无谓的彷徨，将来的你，一定会感谢现在拼命的自己！