//人
class Person
{
public:
	//显示基本信息
	void showInfo()
	{
		cout << _name << "-" << _sex << "-" << _age << endl;
	}
public:
	char* _name;//姓名
	char* _sex;//性别
	int _age;//年龄
};

第二种：声明放在.h文件中，类的定义放在.cpp文件中（更好）

类的访问限定符：

访问限定符：

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

#define _CRT_SECURE_NO_WARNINGS 1
using namespace std;
#include<iostream>
//C，关注的是过程
namespace hzsc
{
	struct Stack
	{
		int*a;
		int top;
		int capacity;
	};
	void StackInit(struct Stack* ps){}
	void StackPush(struct Stack* ps, int x){}
}
//CPP
namespace hzscpp
{
	class Stack
	{
		//访问限定符:
//访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
		//想让你在类外面直接访问的定义成公有
		//不想让你在类外面直接访问的定义成私有
	public:
		void Init(){}
		void Push(int x){}
		void Pop(){}
		void Destory(){}
		//...
	private:
		int*a;
		int top;
		int capacity;
	};
}
int main()
{
	//C
	struct hzsc::Stack stc;
	hzsc::StackInit(&stc);
	hzsc::StackPush(&stc,1);
	hzsc::StackPush(&stc,2);
	//CPP
	hzscpp::Stack stcpp;
    stcpp.Init();
	stcpp.Push(1);
	stcpp.Push(2);
	return 0;
}

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

思考：C++中struct和class的区别是什么？

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

封装

C不封装，比较自有，随便访问数据和方法

C++封装，数据和方法是放到类里面，想给你访问的，定义成公有，不想让你访问的，定义私有

【面试题】面向对象的三大特性：封装、继承、多态。
在类和对象阶段，我们只研究类的封装特性，那什么是封装呢？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装本质上是一种管理：我们如何管理兵马俑呢？比如如果什么都不管，兵马俑就被随意破坏了。那么我们首先建了一座房子把兵马俑给封装起来。但是我们目的全封装起来，不让别人看。所以我们开放了售票通道，可以买票突破封装在合理的监管机制下进去参观。类也是一样，我们使用类数据和方法都封装到一下。
不想给别人看到的，我们使用protected/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;
}

类的实例化

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

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

类对象模型

1.如何计算类对象的大小

结构体内存对齐规则

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

计算类型大小，或者类对象，只考虑成员变量，因为对象中，只存了成员变量，没有存成员函数

下面这段代码输出的结果是什么？

class A
{
public:
	void Print(){}
private:
	int i;
	char ch;
};
//没有成员变量的类
class B
{
public:
	void Print()
	{}
};
//空类
class C
{};
int main()
{
	cout << sizeof(A) << endl;//8
	cout << sizeof(B) << endl;//1
	cout << sizeof(C) << endl;//1
	return 0;
}

如果一个类没有成员，那么他的对象需要给1byte进行占位标识对象的存在，这1byte不存储有效数据

2. 类对象的存储方式猜测

第一：类对象中包含类的各个成员

缺陷：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。

那么如何解决呢？

第二：只保存成员变量，成员函数存放在公共的代码段

this指针

1.this指针的引出

看下面这段代码：

思考：Date类中有SetDate与Display两个成员函数，函数体中没有关于不同对象的区分，那当d1调用Init函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

class Date
{
public:
	//void Display(Data* this)
	void Display()
	{
		cout << _year << "-" << _month << "-"<< _day << endl;
	}
	//void Init(Data*this,int year,int month,int day)
	void Init(int year, int month, int day)
	{
		//成员函数里，我们不加的话，默认会在成员前面加this->
		//我们也可以显示的在成员前面加this->
		this->_year = year;
		this->_month = month;
		this->_day = day;

		//对象可以调用成员函数，成员函数中还可以调用成员函数
		//因为有this指针
		this->Display();
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2;
	d1.Init(2021, 10, 8);//d1.Init(&d1,2021,10,8)
	d2.Init(2022, 10, 8);//d1.Init(&d2,2022,10,8)
	d1.Display();//d1.Display(&d1);
	d2.Display();//d1.Display(&d2);
	return 0;
}

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

2.this指针的特性

思考：this指针存在哪？堆？栈？静态区？常量区？

常犯的错误：this指针存在对象里面(误区)

this指针是形参，形参和函数中局部变量都是存在函数栈祯里面的，所以this指针可以认为是存在栈的

vs下为了提高效率，this指针是通过寄存器ecx传递的

思考下面这段代码的运行结果？编译不通过？崩溃？正常运行？

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

----->运行通过

成员函数的地址不在对象中存储，存在公共代码段

那么这里调用成员函数，不会去访问p指向的空间，也就不存在空指针解引用了

这里只会把p传递给隐含的this指针，但是show函数中也没有解引用this指针

继续思考下面这段代码的运行结果？编译不通过？崩溃？正常运行？

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
}

---->程序崩溃

这里出现崩溃，因为这里this->_a，空指针解引用了！！

p->_a p指向的空间上找_a访问，所以是个解引用行为

p->Show() Show不是存在p指向的对象空间上，不解引用，这里引用是把p传递给形参this

以上是关于C++初阶类和对象的主要内容，如果未能解决你的问题，请参考以下文章

C++ 初阶类和对象

C++初阶类和对象

C++初阶---类和对象

C++初阶第四篇——类和对象（上）（类的定义+封装+this指针）