类与对象 初步认识

[目录]
1.面向过程和面向对象初步认识
2.类的引入
3.类的定义
4.类的作用域
5.类的实例化
6.类的访问限定符及封装
7.类的对象大小的计算
8.类成员函数的this指针

1.面向过程和面向对象初步认识
https://blog.csdn.net/sakeww/article/details/115278428

2.类的引入与定义
在c语言中，可以使用struct来自定义一种新的类型
问题：c语言中struct中可以放函数吗？—不能，只能放数据
验证：
在c语言中

struct student
{
	char _name[20];
	int  _age;

	void setage(int age)
	{
		_age = age;
	}
};

代码运行失败–》说明：c语言中的结构体内部是不能放函数的
上述代码在C++中
代码编译成功–》说明：c++中的结构体是能放函数的

#include 
using namespace std;
//在C++中，struct定义出来的类型就可以看成是一个类了
//C语言中的结构体，在c++中变成-->定义了一个类
//只不过在c++中，如果要定义一个类，我们更喜欢使用class的关键字
struct Student
{
	结构体中的变量
	char _name[20];
	char _gender[3];
	int  _age;

	结构体中的函数
	初始化
	void InitStudent(char name[], char gender[], int age)
	{
		strcpy(_name, name);
		strcpy(_gender,gender);
		_age = age; 
	}

	打印
	void PrintStudent()
	{
		cout << _name << " " << _gender << " " << _age << endl;
	}

	void SetAge(int age)
	{
		_age = age;
	}
};
int main()
{
	return 0;
}

只不过在c++中，如果要定义一个类，我们更喜欢使用class的关键字
即：

#include 
using namespace std;
class Student
{
	结构体中的变量
	char _name[20];
	char _gender[3];
	int  _age;

	结构体中的函数
	初始化
	void InitStudent(char name[], char gender[], int age)
	{
		strcpy(_name, name);
		strcpy(_gender,gender);
		_age = age; 
	}

	打印
	void PrintStudent()
	{
		cout << _name << " " << _gender << " " << _age << endl;
	}

	void SetAge(int age)
	{
		_age = age;
	}
};
int main()
{
	在c语言中可以这样定义
	struct Student s1;
	s1._age = 10;

	在c++中可以这样定义
	Student s2;
	s2.InitStudent("peter", "男", 18);
	s2.SetAge(10);

	return 0;
}

此代码也可以正常运行

3.类的定义
https://blog.csdn.net/sakeww/article/details/115438027

4.类的访问限定符及封装
https://blog.csdn.net/sakeww/article/details/115440196

5.类的作用域
延伸：
CPP中有四个作用域：
1.函数体中的局部作用域
2.函数体中的全局作用域
3.命名空间
4.类

如何验证定义一个类，就是定义一个作用域？
1.类在定义期间，可以将声明和定义在 类体 中同时给出
2.在头文件中声明，在源文件中来进行定义
在源文件中定义期间，你的成员函数名字之前必须要加入类名以及作用域限定符，作用域限定符跟在类名之后，就说明类是一个作用域

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

类和对象–》什么是类？什么是对象？
类：主要是对实体（对象）来进行描述的，描述实体都有那些属性（成员变量），实体中都有那些方法（成员变量）
类也是新定义的一种类型
类是比较抽象的一个概念，是从许多对象中提取出来的一些公共的信息，将数据和方法包装起来，更好的描述实体
类是一张图纸
对象：是实实在在存在的。
是用类产生的一个实体
对象中是可以放数据的
类似一座房子

7.类对象模型
对象模型：对象在内存中的布局方式

如何计算类对象的大小
我们都知道对象中都包含那些内容呢？

class Student
{
public:
	成员变量
	char _name[20];
	char _gender[3];
	int _age;
	20+  3+1 + 4 = 28
	注意内存对齐

public:
	成员函数
	void InitStudent(char name[], char gender[], int age)
	{
		strcpy(_name, name);
		strcpy(_gender, gender);
		_age = age;
	}

	注意：成员函数如果在类内部类进行定义，成员函数可能会被编译器当成内联函数来对待
	void PrintStudent()
	{
		cout << _name << "-" << _gender << "-" << _age << endl;
	}
};

int main()
{
	Student s;
	s.  .成员访问符
	通过对象.的方式发现：Student类型的对象
	 	
	Student s1,s2,s3;
	s1.InitStudent("Peter", "男",18);
	s2.InitStudent("David", "男", 19);
	s3.InitStudent("Lily", "女", 18);

	s1.PrintStudent();
	s2.PrintStudent();
	s3.PrintStudent();

	发现：s1,s2,s3虽然是三个不同的对象，但是最终调用的是相同的方法来进行初始化和打印

	cout << sizeof(s1) << endl;
	实际对象中存储成员的情况：成员变量--实际sizeof的结果

	return 0; 
}

方式一：s. 便可以将后面的成员函数和成员变量看出来
方式二：将每个对象中存储的相同的方法单独来进行存储（这些成员函数实际只需要存储一份，每个对象共享这些方法就可以了）
问题：成员函数从对象中分离出来之后，优点：可以节省空间
问题：对象数据和方法分离开了，当对象使用成员函数时，如何知道成员函数在那里？
指针：指针指向的时：所有成员函数存放位置的首地址
对象的大小：成员变量+指针
成员函数的大小为：成员函数的入口地址大小，一般为四个字节

问题：第二种方法指针怎么指向多个函数的？
答：函数指针数组

计算一个类/对象的大小：只需要将类中的成员变量加起来，注意内存对齐
问题：成员函数存储到哪里去了？
成员函数单独进行存放的，当程序运行起来后，成员函数存储到代码段

class A
{
public:
	void SetA(int a)
	{
		_a = a;
	}
private:
	int _a;
};

class B
{
public:
	void TestB()
	{

	}
};

空类
class C
{};

int main()
{
	结论：求一个类的大小--》只需将类中“成员变量”加起来，注意内存对齐
	cout << sizeof(A) << endl;//4
	cout << sizeof(B) << endl;//1
	cout << sizeof(C) << endl;//1  

	return 0;
}

问题：空类的大小是多少？为什么？
在主流的编译器中：空类的大小给的是1，
我们知道C类是一个空类，我们用C类定义三个对象c1,c2,c3
c1,c2,c3是三个相同的对象还是不同对象
如果空类的大小为0，发现c1,c2,c3这三个对象最终存储在相同的位置上，即这三个对象的地址是一样的
则c1,c2,c3就成为同一个对象（同一个地址）
假设错误，说明空类是有大小的，在主流的编译器中：空类的大小给的是1，将空类大小设置为1目的就是为了区分空类定义出来的不同对象

空的结构体是多少呢？
分析：在c++中，用struct定义出来的结构体就是类----》1

8.类成员函数的this指针
https://blog.csdn.net/sakeww/article/details/116082159