// C++兼容C struct的用法
// C++同时对struct进行了升级，把struct升级成了类

// 1、结构体名称可以做类型
// 2、里面可以定义函数

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

	// 这里并不是必须加_
	// 习惯加这个，用来标识成员变量
	char _name[20];
	char _gender[3];
	int _age;
};

struct ListNode
{
	int val;
    //C++中下面两种写法都可，而C语言只能用注释掉里面的struct ListNode* next
	//struct ListNode* next;
	ListNode* next;
};

在C++中，更喜欢用class来代替struct。

注意：struct默认是共有，class默认是私有

三.类的定义

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

};  // 一定要注意后面的分号

????????class为定义类的关键字，className为类的名字，{}中为类的主体，注意类定义结束时后面的分号。

? ? ? ? 类中的元素称为类的成员；类中的数据称为类的属性或者成员变量；类中的函数称为类的方法或者成员函数。

// 类
// 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;
	cout << s2._age << endl;

	return 0;
}

类的两种定义方式：

（1）声明和定义全部放在类体中

注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

class Student
{
public:
	void Print()
	{
		cout << _name << " " << _gender << " " << _age << endl;
	}

private:
	char _name[20];
	char _gender[3];
};

（2）声明放在.h中（类内），类的定义放在.cpp中（类外）

class Student
{
public:
	void Print();
private:
	char _name[20];
	char _gender[3];
};

//要表明作用域::
void Student::Print()
{
    cout << _name << " " << _gender << " " << _age << endl;
}

一般情况下，如果函数较短可以放在类内，函数较长推荐放在类外。

四.类的访问限定符

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

访问限定符分为3种：

1.public（公有）

2.protected（保护）

3.private（私有）

说明：

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

（2）protected和private修饰的成员在类外不能直接被访问（protected是在继承中引入的）

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

（4）clss的默认访问权限为private，struct的默认访问权限为public（因为struc要兼容C语言）

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

C++中struct和class的区别：

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

五.封装

面向对象的三大特性：封装、继承、多态

类和对象中，我们所研究的就是类的封装特性。

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

封装本质是一种管理。

封装：更严格管理设计

1、数据和方法封装到一起，类里面
2、想给你自由访问的设计成共有，不想给你直接访问的设计成私有

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

C语言中，数据和方法是分离的，比较自由。?

六.类的作用域

????????类定义了一个新的作用域，类的所以成员都在类的作用域中。

????????在类体外定义成员，需要使用 ::作用域解析符指明成员属于哪个类域。

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

// 这里需要指定Print是属于Person这个类域
void Person::Print()
{
	cout << _name << " "_gender << " " << _age << endl;
}

七.类的实例化

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

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

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

（3）举个例子：类实例化出对象就像是设计一个东西时，类就是设计图，只需要设计出有什么东西，但并没有实体，只有实例化出了对象才能实际存储数据，占用物理空间。

class Person
{
    //...
}

int main()
{
    Person p;//实例化对象
}

八.类对象模型

1.类对象存储方式

有两种的可能方式：

方式（1）：对象中包含类的各个成员（不是计算机的实际存储方式）

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

方式（2）只保存成员变量，成员函数存放在公共的代码段。

? ? ? ? 这个是计算机的实际存储方式。

我们看下面这段代码：

// 总结：没有成员变量的类对象，编译器会给他们分配1byte占位，表示对象存在过 
// 类中仅有成员函数
class A2 {
public:
	void f2() {}
};

// 类中什么都没有---空类
class A3
{
	
};

int main()
{
	cout << sizeof(A2) << endl;
	cout << sizeof(A3) << endl;

	A2 aa;
	A2 aaa;
	cout << &aa << endl;
	cout << &aaa << endl;
	
	return 0;
}

这两个类中，一个只有成员函数，一个是空类。

它们的大小比较特殊，因为没有成员变量，我们可能会认为它们的大小都是0，但是实际上不是。

它们的大小都是1，对于没有成员变量的类，编译器会给他们分配1byte占位，表示对象存在过。

结论：一个类的大小，实际就是该类中的成员变量之和，因此要进行内存对齐。

而对于没有成员变量的函数，编译器会给他们分配1byte占位，用来标识这个类，表示对象存在过。

2.计算类对象大小

计算类对象大小，就是计算成员变量的大小，方法与求C语言的结构体大小相同。

它们都会进行内存对齐。

内存对齐：

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

（2）其它成员变量要对齐到对齐数的整数倍的地址处。

????????对齐数 = 编译器默认的一个对齐数与该成员大小的较小值

? ? ? ? VS默认对齐数为8

（3）结构体总大小为：最大对齐数的整数倍

????????最大对齐数：所有变量类型最大者与默认对齐参数较小值

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

举个例子：

class A
{
private:
    int a;
    short b;
    int c;
    char d;
};

a从偏移量为0开始，int占4个字节，到偏移量为4的位置；

b为short，占2个字节，b与默认对齐数8相比，b较小，因此b对齐到2的倍数处，这时因为a占了4个字节，到了偏移量为4的位置，为2的倍数，因此b从偏移量为4的位置开始，占2个字节，到偏移量为6的位置；

c为int，占4个字节，比8小，因此c对齐到4的倍数处，此时偏移量到了6，6不是4的倍数，因此c对齐到距离偏移量6最近的为4的倍数处的位置，即偏移量为8的位置，占4个字节，到偏移量为12的位置；

d为char，占1个字节，比8小，因此d对齐到1的倍数处，c占到偏移量为12的位置，为1的倍数，d占一个字节，到偏移量为13的位置；

a，b，c，d的内存对齐计算之后，应该算总的大小：

所有变量类型最大者：int，4个字节? 4比默认对齐数小，因此总大小应该为4的倍数。距离13最近的4的倍数的数为16，因此总大小为16。

九.this指针

（1）this指针

class Date
{
public:
	//Print的实际调用
	/*void Print(Date* const this)
	{
		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	}*/
	void Print()
	{
		cout << this << endl;
		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	}

	//Init的实际调用
	/*void Init(Date* const this, int year, int month, int day)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}*/
	void Init(int year, int month, int day)
	{
		//this = nullptr; this指针本身不能修改，因为他是const修饰的
		// this指向对象可以被修改
		cout << this << endl;

		this->_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};

int main()
{
	Date d1;
	Date d2;

	cout << "d1:" << &d1 << endl;
	cout << "d2:" << &d2 << endl;

	cout << endl;

	//Init的实际传参
	//d1.Init(&d1, 2022, 5, 15);
	//d2.Init(&d2, 2022, 5, 20);
	d1.Init(2022, 5, 15);
	d2.Init(2022, 5, 20);

	cout << endl;

	//Print的实际传参
	//d1.Print(&d1);
	//d2.Print(&d2);
	d1.Print();
	d2.Print();

	cout << endl;

	Date* p = &d1;
	//实际传过去了p
	//p->Print(p);
	p->Print();

	return 0;
}

输出结果如下：