＜ C++ ＞：C++ 类和对象(上)

2、类的引入

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
//在C语言中,若声明和定义一个学生的结构体,则如下所示:
//struct Student
//{
//	//在C语言中声明和定义结构体的话,结构体成员中只能 声明 变量、
//	char _name[20];
//	char _gender[3];
//	int _age;
//};

//上述代码,若在C语言中就看做是声明和定义的一个结构体,若在C++中则看做是声明和定义了一个类、
//由于C++兼容C语言,所以C++也兼容C语言中的关键字struct的用法,所以在C++中也能够成功执行上述代
//码,只不过是,上述代码在C语言看来就是声明和定义了一个结构体,而在C++看来则是声明和定义了一个类
//,除此之外,在C++中,该类里面不仅仅可以声明变量,也可以声明和定义函数,同时,C++也对C语言中声明
//和定义的struct结构体进行了升级,升级成了类,其主要意义在于:
//1、现C++中的类名Student可以直接作为类型进行使用、
//2、在类里面,除了可以声明变量之外,还可以声明和定义函数、
//在C++中,下述代码则会被视为声明和定义的一个类,其中:struct为类关键字,Student为类名,或者是类标签、

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

	//声明变量、
	//C++中,当在类里面声明变量时,一般在变量名前面或者后面加上_(或者是其他形式,看
//公司,C++并没有规定必须写成什么形式,但Java中有着明确的规定),注意不是必须要加的,主要是用来表
//明这是类里面的成员变量,否则可能在某些地方会出现歧义、
	char _name[20];
	char _gender[3];
	int _age;
};   
//注意:上面的类中的变量的声明和函数的声明和定义的位置是随意的,变量上,函数下或者变量下,
//函数上或者任意位置,都是可以的,这是因为:类是一个整体,此时编译器并不是只会向上找,而是在该类这
//个整体里面去寻找,所以上述写法也是可以的,除了类之外,则编译器均默认是向上查找的,那么上述类里
//面的写法就会出现错误,还要知道,在C++中看到上述代码,要把他看做是声明和定义的一个类,不要把他
//看做是声明和定义的一个结构体,而我们所谓的C++兼容C语言中的关键字struct的用法,只不过是在使用
//时可以按照结构体的用法去使用,但本质上已经升级成了类,所以要看做类去处理、

//在C语言中:
//结构体:
//struct ListNode
//{
//	int val;
//	struct ListNode* next;//不可以写成:ListNode* next,即使加上typedef也是不可以的,如下所示:
//};

//结构体:
//typedef struct ListNode
//{
//	int val;
//	ListNode* next; //错误写法、
//}ListNode;

//在C++中可以写成如下所示:
//类:类,不是只能声明和定义一个,可以声明和定义多个、
//struct ListNode
//{
//	int val;
//	//C++兼容C语言中struct的用法:
//	struct ListNode* next;//正确写法、
//	//新增用法:这是因为C++对C语言中声明和定义的struct结构体升级成了类,下面则是类新增的使用方法:
//	ListNode* next; //正确写法、
//};

//在C++中一般不需要再对struct ListNode进行typedef为ListNode,因为类名可以直接当做类型进行
//使用,除非类名过长,若再想对类名进行重命名的话,一般写成下面这种情况:
//一、
//struct ListNode
//{
//	int val;
//	ListNode* next;
//};
//typedef ListNode ST;//struct ListNode s2; 或者 ListNode s2; 或者 ST s2; 其中: ST s2; === ListNode s2;
//二、
//struct ListNode
//{
//	int val;
//	ListNode* next;
//};
//typedef struct ListNode ST; //struct ListNode s2; 或者 ListNode s2; 或者 ST s2; 其中: ST s2; === struct ListNode s2;
//将struct ListNode重命名为ST,即:将typedef与最后一个单词(ST)两者中间的内容(struct ListNode)重命名为最后一个单词(ST),并且该单词(ST)中不能存在空格、
//上述方法一般不经常使用,意义不大、

int main()
{
	//C++兼容C语言中struct结构体的用法,如下所示:
	//struct Student s1;  //s1在C++中常称为对象,类声明和定义的对象、
	//新增用法如下:
	Student s2;           //s2在C++中常称为对象,类声明和定义的对象、
	
    //访问类里面声明的变量:
	s2._age = 10;
	//调用类里面声明和定义的函数;
	s2.Init("惠俊明", "男", 25); //初始化、
	s2.Print();//打印、 //惠俊明 男 25
	return 0;
}

类的声明和定义 或 类的定义(可以理解成声明和定义)：

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

        class 为类的关键字，className 为类的名字，{ }中为类的主体，注意在结束时后面有一个分号、

        类体中的内容称为类的成员：类体中的变量称为类的属性、类的数据、类成员对象或者类成员变量；类体中的函数称为类的方法或者类成员函数、

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

3.1、访问限定符

//一、
//C语言声明和定义栈结构、
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
//在C语言中声明和定义或定义(可以理解成声明和定义)的栈结构的数据和方法是分离的、
struct Stack
{
	//栈结构的结构体成员变量/数据/属性、
	int* a;
	int top;
	int capacity;
};
//栈结构操纵数据的方法、
void StackInit(struct Stack*ps)
{
	ps->a = NULL;
	ps->top = 0; //ps->top = -1;
	ps->capacity = 0;
}
void StackPush(struct Stack*ps, int x)
{}  //具体实现省略、
int StackTop(struct Stack*ps)
{}  //具体实现省略,以此方法为例、
//在C语言中声明和定义或定义(可以理解成声明和定义)的栈结构的数据和方法是分离的,会存在什么样的问题呢？
//太过自由,不能很好的进行管理,如下所示：
int main()
{
	//声明和定义一个栈(局部结构体变量)、
	struct Stack st;
	//初始化栈、
	StackInit(&st);
	//入栈数据、
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);

	//取栈顶元素、
	//方法一: 规范的方法是调用函数接口来取栈顶元素、
	printf("%d\n", StackTop(&st));

	//方法二: 不规范的方法、
	printf("%d\n", st.a[st.top]);
	//方法二也是可以的,但是会在某些情况下存在歧义,比如:top不明确到底是栈顶元素的位置还是栈顶
//元素的下一个位置,此时,使用者就可能存在误用,top不明确到底是栈顶元素的位置还是栈顶元素的下一
//个位置,取决于初始化,若初始化top为0,则正确访问应该写成:printf("%d\n", st.a[st.top-1]);
//若初始化top为-1,则正确写法应是: printf("%d\n", st.a[st.top]); 数据结构只是一个思想,并没
//有规定必须把top初始化为某个值,所以使用方法二是不合适的,即,太过自由,不能很好的进行管理,是不
//好的、
	//这是因为方法二的使用和栈结构的结构体成员变量/数据/属性的声明是具有联系的,比如:
//top初始化的值决定了方法二中到底使用那个语句,其次,如果改成链表来实现栈结构的话,那么方法二也
//需要进行改动才可以达到目的、
	return 0;
}


//接下来看一下C++是如何解决上述问题的: C++不会存在像上面这种误用的情况,所以不会出现歧义的,这
//是因为C++设计出了类、


//二、
//C++声明和定义栈结构、
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
//在C++中声明和定义或定义(可以理解成声明和定义)的栈结构的 类的数据和类的方法 是合并的、
//1、类的数据和类的方法一起封装到类里面、
//2、当封装到一起后才可以控制访问权限,这样在C语言中若直接通过 数据 进行访问的话,可能会存在
//歧义,但是若在C++中,把类的方法和类的数据都封装到类中,再把类的数据设置为私有,把类的方法设置
//为公开,这样一来,在类外面就不可以直接访问私有的内容,这样就不可以通过类的数据来进行直接访问,
//就避免了上述可能会出现的歧义、
class Stack
{
	//C++的封装本质上就是一种更加严格管理的设计、
	//一般情况下,设计类,类成员变量/类的数据/类的属性都是设置成私有或者保护的,类的方法,即类成
//员函数的权限要分情况考虑,若想开源的就设置成公用,若不想开源的就设置成私有或者保护即可,所以类成
//员函数(类的方法)并不是一定为公用也不是一定为私有或保护的,要根据自己的情况进行设定,但类成员
//变量/类的数据/类的属性在一般情况下都会设置成私有或保护的、
private:
	void CheckCapacity()
	{}    //用户没有必须去调用判断是否需要增容的函数接口,所以就设置成私有或者保护的即可、
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);
	//取栈顶元素、
	//只能通过调用函数接口来取栈顶元素、
	cout << st.Top() << endl;
	//错误方法:
	//cout << st._a[st._top] << endl;//这是因为在类里面已经把 类的数据 设置为私有,所以在类
//的外面不可以直接进行访问,这样要想成功运行,必须使用上述的方法,所以就避免了出现歧义,这样就不
//需要考虑到底把top初始化为0还是-1了,不需要关心,这就体现出了C++强制的通过定义使得用户在使用
//的时候更加规范,这样一来,不需要考虑栈到底是使用顺序表还是链表来实现的,也不需要考虑top的值到
//底初始化为0还是-1,只需要调用对应的函数接口就可以达到目的,底层的实现过程不需要考虑,都不会影
//响调用函数接口得到的结果,这就叫做低耦合,关联关系低,在C语言中如果只使用方法一的话也可以做到
//低耦合,但是避免不了会有人误用了方法二,这样就会出现问题,而在C++中,已经规定了类似于C语言中方
//法二的用法是错误的,所以就避免了出现歧义的情况关联关系越高,越不好、
	return 0;
}

//类成员函数在类内进行声明和定义、
//Stack.h文件
#pragma once
class Stack
{
public:
	//类成员函数的声明和定义:
	void Init()  //不需要再指定类域、
	{
		//从类内进行的访问、
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
	void Push(int x)//不需要再指定类域、
	{}
	void Pop()//不需要再指定类域、
	{}
private:
	int* _a;
	int _top;
	int _capacity;
};

//类成员函数在 类外 进行定义(可以理解成声明和定义)、
//Stack.h文件
#pragma once
class Stack
{
public:
	//类成员函数的声明:
	void Init();
	void Push(int x);
	void Pop();
private:
	int* _a;
	int _top;
	int _capacity;
};


//Stack.cpp文件
#include"Stack.h"
//类成员函数的定义(可以理解成声明和定义):
void Stack::Init() //指定类域、
{
	_a = nullptr;
	_top = 0;
	_capacity = 0;
}
    //访问限定符限制的是从 类外 进行的直接访问,此处在类成员函数Init的定义(可以理解成声明和
//定义)里面直接访问类成员变量,即类成员函数访问类成员变量不属于从类外进行的直接访问(属于从类内
//进行的直接访问),因为,虽然该类成员函数的定义(可以理解成声明和定义)在类外,但是该类成员函数的
//声明在类内,此处我们要以声明所在的位置为准,所以,即使该类成员函数的定义(可以理解成声明和定义)
//在类外,但其仍是类成员函数,而该类成员函数的函数体内中的所有内容均属于该类成员函数,所以,该类
//成员函数访问类成员变量就属于是从类内进行的直接访问,所以这种情况下,访问限定符不起任何作用、

    //访问限定符限制的是从类外进行的直接访问,但是限制不了从类外进行的间接访问,具体在后面进行
//阐述,并且访问限定符不限定从类内进行的直接访问,且不考虑从类体内进行的间接访问;从类内可以任意
//直接访问到私有、保护和公用的内容、

void Stack::Push(int x) //指定类域、
{}
void Stack::Pop()       //指定类域、
{}

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

1、

        类只是一个模型一样的东西，是一种自定义的数据类型， 系统并不为类分配存储空间 ，其限定了类有哪些成员， 声明和定义或定义(可以理解成声明和定义)出一个类，并没有分配实际的内存空间来存储它，在 C 语言中声明和定义或定义(可以理解成声明和定义)出一个结构体，也没有分配实际的内存空间 ，在通常情况下，我们讨论 "分配内存空间" 时，指的仅仅是数据，对于代码和语义的东西，那完全是不同的概念，比如说函数，他本来由高级语言编写，编译后只不过是转换成机器语言代码，保存在程序中而已，其它没什么实质变化，程序运行时，所有的机器语言代码都调入内存，用到谁就一条条地执行谁，所以，上述所谓的并没有分配实际的内存空间来存储它，指的只是类体里面的类的数据，并没有指类体中的类的方法，在类体中既可以声明类的数据，也可以声明和定义类的方法，类的方法是以函数体二进制代码的形式存放在内存中的公共代码区上的，类的数据(即类成员变量，它不属于局部变量，也不属于全局变量)，目前来说，不考虑 C 语言中在结构体成员变量前面加上关键字 static 的情况，类本身并不可以存储数据，但类声明和定义出或者是实例化出的对象就可以存储数据了，C 语言中 声明和定义或定义(可以理解成声明和定义) 的结构体本身不可以存储数据，但是由结构体类型声明和定义出的结构体变量就可以存储数据了、

2、

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

3、

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

4、

        所谓的计算所占内存空间的大小，包括占用的内存空间中的所有的区， 而在计算类实例化出来的对象的大小时，并没有计算类中的类成员函数(包括静态和非静态类成员函数)所占的内存大小 ，是因为：类成员函数(包括静态和非静态类成员函数)并不存在于类实例化出来的对象里面，类成员函数(包括静态和非静态类成员函数)是共用的，假设有一个调用函数为：void HjmLcc() { }，该调用函数可以作为非静态类成员函数，也可以作为非静态全局函数，只不过是，当作为非静态类成员函数时仅仅比作为非静态全局函数时，在形参列表中会多出一个 this 指针而已，其他地方则没有区别，类实例化出来的对象里面无非就是对类的数据进行的实例化，函数不管是全局函数(包括非静态和静态)还是类成员函数(包括非静态和静态)，均是以函数体二进制代码的形式在内存中的公共代码区上为其开辟内存空间，这两者都是在进行调用时才会在  栈区  上建立栈帧、

5、

        类的静态类成员变量在类声明和定义或定义(可以理解成声明和定义)时就已经在全局数据区为其分配了内存空间，因而它是属于类的，对于非静态类成员变量，是在类的实例化过程中(构造对象)才在栈区，数据段(静态区或全局数据区)或者堆区为其分配内存空间，是为每个对象生成一个拷贝，所以它是属于对象的、

6、

        应当说明，常说的 "某某对象的类成员函数" ，是从逻辑的角度而言的，而类成员函数的存储方式，是从物理的角度而言的，二者是不矛盾的、

7、

        静态类成员函数和非静态类成员函数的区别：静态类成员函数和非静态类成员函数都是在类的声明和定义或定义(可以理解成声明和定义)时放在内存的公共代码区的，因而可以说它们都是属于类的，但是类为什么只能直接调用静态类成员函数，而非静态类成员函数(即使该函数看起来没有参数)只有类对象才能调用呢？原因是类的非静态类成员函数其实都内含了一个指向类对象的指针型参数(即 this 指针)，因而只有类对象才能调用(此时 this 指针有实值)、

8、

       类成员函数的代码段都用同一种方式存储，不要将类成员函数的这种存储方式和inline(内联)函数的概念混淆，不要误以为用 inline声明(或默认为inline)的类成员函数，其代码占用对象的存储空间，而不用 inline声明的类成员函数，其代码不占用对象的存储空间，不论是否用 inline声明(或默认为inline)，类成员函数的代码都不占用对象的存储空间，用 inline声明的作用是在调用该函数时，将函数的代码复制插入到函数调用点，而若不用 inline声明，在调用该函数时，流程转去函数代码的入口地址，在执行完该函数代码后，流程返回函数调用点，inline与类成员函数是否占用对象的存储空间无关，它们不属于同一个问題，不应搞混、

#include <iostream>
using namespace std;
//静态类成员变量:
class Person
{
public:
	//int m_A; //非静态类成员变量,只是声明、
	static int _mA;//静态类成员变量,只是声明,类内声明、

	//静态类成员变量也具有访问权限、
private:
	static int _mB; //静态类成员变量,只是声明,类内声明、
};
int Person::_mA = 100; //类外定义(可以理解成声明和定义)和初始化,要指定类域、
//类外定义(可以理解成声明和定义)和初始化,但不能在main函数中进行,还要保证在 类体外 的下面进行
//,因为使用到了 Person::,若在 类体外 上面进行的话,系统会向上查找 Person:: ,就找不到,所以会
//报错,在满足上述条件的基础下,可以在任意位置进行静态类成员变量的定义(可以理解成声明和定义)和
//初始化,其格式如上所示、
//上述在进行静态类成员变量的定义(可以理解成声明和定义)和初始化时,必须要进行指定类域,若写成:
//int _mA = 10;的话,这代表的是声明和定义全局变量,这样就看不出来是对类体中的静态类成员变量进
//行的定义(可以理解成声明和定义)和初始化,所以必须要指定类域才可以、

//类外定义(可以理解成声明和定义)和初始化:
int Person::_mB = 200;
void test01()
{
	Person p;
	cout << p._mA << endl; //100
	Person p2;
	p2._mA = 200;
	cout << p._mA << endl;//200
}
void test02()
{
	//非静态类成员变量属于对象,而不属于类,所以其访问形式只能通过对象或通过匿名对象突破类域进
//行访问,不可以通过类名加作用域限定符的形式进行访问、

    //此处的静态类成员变量_mA为公有,可以在类外直接访问、
	//静态类成员变量不属于对象,而属于类,其访问形式有:
	//1、通过对象进行访问静态类成员变量:
	Person p;
	cout << p._mA << endl; //100

	//2、通过类名加作用域限定符的形式进行访问静态类成员变量,也可以不用创建对象再使用对象来进
//行访问,因为静态类成员变量本身就不属于对象,而属于类、
	cout << Person::_mA << endl; //100
	
    //3、
    cout << Person()._mA << endl; //通过匿名对象突破类域进行访问、


	//cout << Person::_mB << endl; //错误写法,在类外不可以直接访问私有的静态类成员变量、
}
int main()
{
	//test01();
	test02();
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
//定义一个自定义类型的类,类名为A,计算程序中创建(实例化)出了多少个 A 类型的对象、
//直接数的话可能不准确,因为会涉及到编译器的优化, A 类型的对象可能是调用一次拷贝构造函数出来的
//也有可能是我们自己创建出来的,此时他会自动调用一次构造函数,即,实例化出一个 A 类型的对象,那么
//就一定调用一次构造函数或者是调用一次拷贝构造函数,所以我们只需要统计一下,调用构造函数和调用
//拷贝构造函数的总共的次数,得到的就是创建出 A 类型的对象的个数、

//int count = 0; //全局变量,可能会存在命名冲突的问题、
    //但是使用全局变量也会存在一些问题,比如,全局变量用在项目中,若全局变量声明和定义在.h头文
//件的话,当在多个.cpp源文件中包含头文件后,就会出现链接冲突,和在头文件中声明和定义全局函数造
//成的问题类似,也可以使用全局变量的定义(可以理解成声明和定义)和声明分离的方法,但是,会比较麻烦
//,并且C++编译器从封装的角度而言并不提倡使用全局变量,因为别处也能够操作该全局变量,此时就可以
//使用静态类成员变量,封装性也比较好、

class A
{
public:
	A()
	{
		_count++;
	}
	A(const A& aa)
	{
		_count++;
	}
	static int Get_count() 
	{
		return _count;
	}
    //静态类成员函数,属于整个类,即属于由该类实例化出来的所有对象,不属于某一个对象,且形参列表
//中的第一个位置上没有隐藏的this指针、

private:
	static int _count;  //静态类成员变量在类内声明、
};

//静态类成员变量在类外进行定义(可以理解成声明和定义)、
int A::_count = 0;
//自定义类型的对象 传值 传参和 传值 返回、
A Func(A a)
{
	A copy(a);
	return copy;
}
int main()
{
	A a1;
	A a2=Func(a1);

	//cout << sizeof(a1) <<endl;
	//此时不考虑类体中静态类成员变量所占的内存空间,因为静态类成员变量属于整个类,属于由该类实
//例化出来的所有的对象,而不属于某一个对象、
//注意:在计算时不要把静态类成员(主要指的是静态类成员变量)算进去、

	//非静态类成员变量属于某一个对象,所以在类外只能通过对象或通过匿名对象突破类域去访问,而静
//态类成员变量属于整个类,即属于由该类实例化出来的所有的对象,故,在类外可以通过类名加作用域限定
//符的形式去访问,也可以通过对象或通过匿名对象突破类域去访问,在此默认类体中的类成员变量是公
//有的、
	//cout << A::_count << endl; 
	//cout << a1._count << endl;  
	//cout << a2._count << endl;  
    //cout << A()._count << endl; //5、

	//非静态类成员函数虽然属于类,但是在类外只能通过对象或通过匿名对象突破类域去访问,静态类成
//员函数属于整个类,即属于由该类实例化出来的所有的对象,故,在类外可以通过类名加作用域限定符的形
//式去访问,也可以通过对象或通过匿名对象突破类域去访问、
	//当使用对象进行访问时,并不是传某一个对象的地址给该静态类成员函数形参中第一个位置上隐藏
//的this指针,因为静态类成员函数形参列表中不存在隐藏的this指针,而是通过所使用的对象来告诉编译
//器去类体中查找该静态类成员函数,此时类体中的类成员变量是私有的、
	cout << a1.Get_count() << endl;   //5、
	cout << a2.Get_count() << endl;   //5、
	cout << A::Get_count() << endl;   //5、
    cout << A().Get_count() << endl;  //6、
	
    return 0;
}

#include <iostream>
using namespace std;
//静态类成员函数:
//1、均共享同一个静态类成员函数、
//2、静态类成员函数只能访问静态类成员变量,不能访问非静态类成员变量、
class Person
{
public:
	//void func() //非静态类成员函数的声明和定义、
	//{}
	static void func() //静态类成员函数的声明和定义、
	{
		_mA = 100;
    //类体内的类成员函数访问类成员变量不受访问限定符的限制,限定符只限制从类外进行的直接访问,
//类成员函数可以直接访问类成员变量,类体内的一切对于类成员函数而言都是透明的,所以上述操作是可
//以的,即使静态类成员变量_mA是私有的,也是可以的,这就是所谓的静态类成员函数可以访问静态类成员
//变量、
		cout << "static void func调用" << endl;
		//_mB = 200;
		//报错,静态类成员函数不可以访问非静态类成员变量,原因是:静态类成员函数的形参列表中不
//存在隐藏的 this 指针,首先,该静态类成员函数在内存中(公共代码区)只有一份,非静态类成员变量属
//于对象,而不属于类,所以其访问形式只能通过对象进行访问,所以要先创建对象,再通过该对象来访问该
//非静态类成员变量,而静态类成员函数也是共用的,大家共享同一份静态类成员函数,比如由该类名
//Person实例化出来了两个对象分别为:P1和P2,然后再通过这两个对象调用同一个静态类成员函数func来
//访问该非静态类成员变量_mB,而该函数体(不管是静态类成员函数还是非静态类成员函数)中并不能区分
//不同的对象,虽然对象P1和P2在调用这个静态类成员函数func,但是该函数体内并不能区分不同的对象,
//所以静态类成员函数不可以访问非静态类成员变量,因为静态类成员函数中并没有内含 this 指针,但是
//在非静态类成员函数中是可以访问非静态类成员变量的,即使其非静态类成员函数的函数体内不能区分不
//同的对象,但非静态类成员函数中都内含了一个 this 指针,所以也可以达到目的,而这里为什么静态类
//成员函数可以访问静态类成员变量,是因为:静态类成员变量_mA并不属于对象,而是属于类,该静态类成
//员变量_mA是共享的,大家均共用同一份静态类成员变量_mA,所以在该静态类成员函数的函数体内并不需
//要区分该静态类成员变量_mA到底属于哪个对象,因为静态类成员变量_mA根本就不属于对象,而属于类,
//大家都共享同一份静态类成员变量_mA,不需要来区分该静态类成员变量_mA到底属于哪个对象,所以,静
//态类成员函数是可以访问静态类成员变量的、
	}
	//静态类成员变量、
	static int _mA;//静态类成员变量,只是声明,静态类成员变量要在类内声明、
	//非静态类成员变量、
	int _mB;//非静态类成员变量,只是声明、

	//静态类成员函数也具有访问权限、
private:
	static void func2()
	{
		cout << "static void func2调用" << endl;
	}
};
//静态类成员变量要在类外定义(可以理解成声明和定义)和初始化、
int Person::_mA = 0; //静态类成员变量在类外定义(可以理解成声明和定义)和初始化,要指定类域、
void test01()
{
	//非静态类成员函数也属于类,而不属于对象,但是由于非静态类成员函数其实都内含了一个指向类对
//象的指针型参数(即 this 指针),所以即使它属于类,但是其访问形式也只有两种,即只有通过对象或通
//过匿名对象突破类域来访问非静态类成员函数(此时 this 指针有实值),而不可以通过下述的方式2进行
//访问非静态类成员函数、

	//静态类成员函数不属于对象,而属于类,所以它有三种访问形式:
	//1、通过对象进行访问静态类成员函数、
	//Person p;
	//p.func(); //static void func调用

	//2、通过类名加作用域限定符的形式进行访问静态类成员函数,也可以不用创建对象再使用对象来进
//行访问,因为静态类成员函数本身就不属于对象,而属于类、
	Person::func(); //static void func调用

    //3、通过匿名对象突破类域进行访问静态类成员函数、
    //Person().func(); //static void func调用

	//1、
	//Person p;
	//cout << p._mA << endl;//100
	//2、
	//cout<< Person::_mA << endl;//100
    //3、
	//cout << Person()._mA << endl;//100

	//1、
	//Person p1;
	//p1.func2(); //报错,在 类外 不可以直接访问私有的静态类成员函数、
	//2、
	//Person::func2();//报错,在 类外 不可以直接访问私有的静态类成员函数、
	//3、
	//Person().func2();//报错,在 类外 不可以直接访问私有的静态类成员函数、
}
int main()
{
	test01();
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using std::cout;
using std::cin;
using std::endl;
class Date
{
public:
	Date(int h = 10)
	{
		_h = h;
	}
	static void Print(); //静态类成员函数的声明、
private:
	int _h;
};
void Date::Print() //静态类成员函数的定义(可以理解成声明和定义),要指定类域且不加关键字static、
{
	cout << "静态类成员函数" << endl;
}
int main()
{
	Date d1;
	d1.Print();
	return 0;
}

        注意：在此不考虑 C 语言中在结构体成员变量前面加关键字 static 的情况，所以当说到静态成员时，就默认指的是 C++ 中类体里面的静态类成员变量和静态类成员函数、

类的定义不能像下面这样进行定义，否则在实例化的时候会出现错误：

class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int _age;
    Person p;
};

        在实例化的过程中将会无穷无尽，这是被 C++ 语法所不允许的，结论：在类的定义中，类成员变量不能使用当前类名作为其类型、

7、类对象模型

7.1、如何计算类对象的大小

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

7.2、类对象的存储方式猜测

class stu
{
public:
	void SetStuInfo()
	{}
	void PrintInfo()
	{}
//类成员函数以其地址的形式进行存储、
private:
	char _name[10];
	int _age;
	char _sex[5];
};

一：对象中包含类的所有成员：

        当计算由类实例化出来的对象所占内存空间的大小时，若对象中包含类的所有的成员，包括类的成员函数时，那么在计算时，就默认类的成员函数以其地址(4/8byte)进行存储：

        缺陷：每个对象中类成员变量所存储的值是不同的，但是调用同一份类成员函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码(类成员函数的地址)，相同代码(类成员函数的地址)保存多次，浪费空间，但这并不是说方式一不可以，它是可以的，但不太好，那么如何解决呢？

#include <iostream>
using namespace std;
class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1, d2;
	//此处调用的类成员函数Init是同一份类成员函数(公共代码区),此处调用的类成员函数Print是同一
//份类成员函数(公共代码区)、
	d1.Init(2022, 5, 11);
	d2.Init(2022, 5, 12);
	d1.Print();  //2022-5-11
	d2.Print();  //2022-5-12
	return 0;
}

        观察上述打印出来的结果，考虑，在此处，两次调用的类成员函数 Print 是同一份类成员函数(公共代码区)，而观察类体内的类成员函数 Print 的声明和定义可知，虽然通过对象 d1 和 d2 来调用该类成员函数 Print ，但是该类成员函数 Print 的函数体内并不能进行区分对象，那么该类成员函数 Print 是怎么来打印出正确匹配的结果呢？

        即：当通过对象 d1 调用类成员函数 Print 时，该类成员函数 Print 是如何知道应该打印对象d1 中的类成员变量，而不是打印对象 d2 中的类成员变量的呢，同理，两次调用的类成员函数 Init是同一份类成员函数(公共代码区)，而观察类体内的类成员函数 Init 的声明和定义可知，虽然通过对象 d1 和 d2 来调用该类成员函数 Init ，但是该类成员函数 Init 的函数体内也不能进行区分对象，(一般情况下，不管是全局函数(包括静态和非静态)还是静态或非静态类成员函数，其函数体内都不能进行对象的区分)，那么该类成员函数 Init 是怎么来初始化出正确匹配的结果的呢，即当通过对象 d1 来调用类成员函数 Init 时，该类成员函数 Init 是如何知道应该设置对象的 d1 中的类成员变量，而不是设置对象 d2 中的类成员变量的呢，此时，这两个类成员函数均不属于某一个对象，而是属于类，这是因为，每个非静态类成员函数内部均内含了一个 this 指针，上述代码中的两个类成员函数会被编译器进行处理，如下所示：

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

//隐含的 this 指针、
//每一个非静态类成员函数中都内含了一个this指针,但是每一个非静态类成员函数的形参和实参部分都不能
//显式的写出来有关this指针的内容,因为这是隐含的this指针,是编译器做的活,但是在把非静态类成员
//函数的声明和定义(可以理解成声明和定义)都放在类体里面的前提下,是可以且 只能 在该非静态类成员函
//数的 函数体 内显式的使用this指针变量的,此时该非静态类成员函数的形参和实参部分仍不能显式的
//写出this指针的内容,因为并不属于该非静态类成员函数的函数体、
#include <iostream>
using namespace std;
class Date
{
public:
	//const放在了this的左边,修饰的是this指针变量,其本身不能被修改,但是this指针变量所指的内
//容是可以被改变的、

	void Print(Date* const this)  
    //该行代码不可以这样写,即:非静态类成员函数的形参部分不能显式的写出有关this指针的内容,
//this是一个形参指针变量,也是一个新增的关键字、
	{
		cout << this << endl;//该行代码可这样写,不会报错,因为在满足上述的前提下,可以且只能
//在该非静态类成员函数的函数体内显式的使用this指针变量的、
		//所有访问类成员变量的地方,前面都会加上一个 this-> 、
		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;  
        //该行代码可这样写,不会报错,原因同上,若自己不加上this->的话,编译器也会自己加上,所以
//一般情况下不需要手动加上、
		//此处访问的是某个对象的_year,_month,_day,并不是类体中的,具体是哪个对象,就看实参传
//的是哪个对象的地址,这是因为类体中的类成员变量只是声明,不是定义(可以理解成声明和定义)、
	}
	//const放在了this的左边,修饰的是this指针变量,其本身不能进行改变,但是this指针变量所指的内容是可以被改变的、
	void Init(Date* const this, int year, int month, int day) //该行代码不可以这样写,原因同上,Date* const this要放在第一个形参位置上、
	{
		//this = nullptr; //this指针变量本身不能被修改、
		cout << this << endl;//该行代码可这样写,不会报错,原因同上、
		//所有访问类成员变量的地方,前面都会加上一个 this-> 、

		//this指针所指的对象是可以被修改的、
		this->_year = year;   //该行代码可这样写,不会报错,原因同上,若自己不加上this->的话,编译器也会自己加上,所以一般情况下不需要手动加上、
		this->_month = month; //该行代码可这样写,不会报错,原因同上,若自己不加上this->的话,编译器也会自己加上,所以一般情况下不需要手动加上、
		this->_day = day;	  //该行代码可这样写,不会报错,原因同上,若自己不加上this->的话,编译器也会自己加上,所以一般情况下不需要手动加上、
		
        //此处访问的是某个对象的_year,_month,_day,并不是类体中的,具体是哪个对象,就看实参传的是哪个对象的地址,这是因为类体中的类成员变量只是声明,不是定义(可以理解成声明和定义)、
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1, d2;
	//此处调用的类成员函数Init是同一份类成员函数(公共代码区),此处调用的类成员函数Print是同一份类成员函数(公共代码区)、
	d1.Init(&d1, 2022, 5, 11); //&d1要放在实参的第一个位置上,该行代码不可以这样写,原因同上、
	d2.Init(&d2, 2022, 5, 12); //&d2要放在实参的第一个位置上,该行代码不可以这样写,原因同上、
	d1.Print(&d1);  //2022-5-11  ,该行代码不可以这样写,原因同上、
	d2.Print(&d2);  //2022-5-12  ,该行代码不可以这样写,原因同上、
    //此处的 &d1 和 &d2 都属于有关 this 指针的内容,在实参部分都不能 显式 的写出、
	return 0;
}