class Student        //类
{
	void Init(const char* name, const char* gender, int age)
	{
		strcpy(_name, name);
		strcpy(_gender, gender);
		_age = age;
	}

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

	// 这里并不是必须加_
	// 习惯加这个，用来标识成员变量
	char _name[20];
	char _gender[3];
	int _age;
};
int main()
{
	Student s2;   //对象     
	s1.Init("张三", "男", 18);
	s1.Print();

	return 0;
}

 3.类的定义

class className
{
 类体：由成员函数和成员变量组成
 
};  一定要注意后面的分号

4.访问限定符

 private私有 是防止你在类外面用对象直接访问：拿栈举例子

class Stack
{
public:
	void Init();
	void Push(int x);
	int Top();
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st1;
	st1._top;	这样就是从类外面访问，错误！
}

当类定义在stack.h文件中：
class Stack
{
public:
	void Init();
	void Push(int x);
	int Top();
private:
	int* _a;
	int _top;
	int _capacity;
};

.cpp文件中访问
#include"stack.h"
void Stack::Init()
{
	_a = nullptr;
	_top = 0;
	_capacity = 0;
}

// struct 不加访问限定符，默认是public
// class 不加访问限定符，默认是private
class Student
{
public:
	// 类体：由成员函数和成员变量组成
	void Init(const char* name, const char* gender, int age)
	{
		strcpy(_name, name);
		strcpy(_gender, gender);
		_age = age;
	}

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

private:
	char _name[20];
	char _gender[3];
protected:
	int _age;
};

int main()
{
	Student s2;
	s2.Init("张三", "男", 18);
	s2.Print();

	//cout << s2._name << endl;     类外面无法访问private修饰的类的成员变量
	//cout << s2._age << endl;      类外面无法访问protected修饰的类的成员变量

	return 0;
}

封装：更严格管理设计

1、数据和方法封装到一起，类里面

2、想给你自由访问的设计成共有，不想给你直接访问的设计成私有

 一般情况设计类，成员数据都是私有或者保护，想给使用者访问的函数是共有，不想给使用者访问时私有或保护

举例：

class Stack
{
private:
	void Checkcapaicty()    //增容接口不想让使用者访问也可以设为私有
	{}
public:
	void Init()
	{}

	void Push(int x)
	{}

	int Top()
	{}

private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	st.Push(3);
	st.Push(4);

	cout << st.Top() << endl;
	//cout << st._a[st._top] << endl;

	return 0;
}

6.类的作用域

（1）概念

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

（2）细节1：不同的类域是可以有同名函数的，并且跟函数重载没关系

 两个类域
class Stack
{
public:
	void Push(int x)
	{}
};

class Queue
{
public:
	void Push(int x)
	{}
};

（3）细节2：在类里面定义的函数默认是inline

class Stack
{
public:
	// 在类里面定义
	// 在类里面定义的函数默认是inline
	void Init()
	{
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}

	// 在类里面声明， 在.cpp里面定义
	void Push(int x);
	void Pop();
	// 总结一下：实际中，一般情况下，短小函数可以直接在类里面定义，长一点函数声明和定义分离
private:
	// 声明
	int* _a;
	int _top;
	int _capacity;
};

总结：实际中，一般情况下，短小函数可以直接在类里面定义，长一点函数声明和定义分离

————————————————————————————手动分割符————————

补充知识点1：声明和定义的区分：开辟了空间就是定义！

类中的成员变量也是声明

private:
	// 声明
	int* _a;
	int _top;
	int _capacity;

类中的成员变量的定义在哪？：在创建对象的时候，开辟了成员变量的空间，所以属于定义（此时st1内部的值未初始化都是随机值）

int main()
{
	Stack st1;
}

————————————————————————————手动分割符————————

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

    void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
Print加上this指针后就是如下：
    //void Print(Date* this)
	//{
	//	cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	//}

Date d1;
d1.Init(2022, 5, 11);    //d1.Init(&d1, 2022, 5, 15);
类里面成员函数：
void Init(int year, int month, int day)
//void Init(Date* const this, int year, int month, int day)

(3)关于this指针的一个面试题

面试题1

【1】下面程序编译运行结果是？  A、编译报错  B、运行崩溃  C、正常运行

class A
{
public:
	void Show()
	{
		cout << this << endl;    //打印空指针也没错
		cout << "Show()" << endl;
	}
//private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Show();
    //如果是 p->_a; 就有错
}

————————————————————————————手动分割符————————

补充知识点2：编译错误和运行崩溃区别

在编译成中间语言的时候就没通过,也就是语法有错误,简单的说,

就是"你说的话,人家完全听不懂,没法帮你编译"所以是编译错误,

这个是原则性的错误.这个图就是语法错误！！

而编译通过了,但是运行时错误,说明编程人员对代码的思想有错误,

简单的说就是"你说的话,人家听得懂,但是不明白你什么意识",语无伦次的

让对方不知道你想做什么,就运行时错误了.

————————————————————————————手动分割符————————

选C、正常运行。首先一定不能选A，因为野指针问题都是运行时崩溃，编译器并不能自己检查出来

尽管p是空指针，但空指针是实参，把空指针实参传给形参是没错的，并且p-> Show()  ,Show()成员函数放在公共的代码区，编译时去公共的代码区找到函数Show()，转换成 “call（函数的地址）”，就是普通的函数调用，cal1  A: :Show ( 0BA14D8h)，并没有解引用空指针

 p->_a; 类里面只存成员变量，访问了空指针的成员变量，解引用空指针会报错，所以错误，但是不会崩溃，编译器优化会忽略这个代码，因为什么事都没做。如果是访问修改这个代码就会报错： p->_a=0;

面试题2

【2】下面程序编译运行结果是？  A、编译报错  B、运行崩溃  C、正常运行

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->PrintA();

}