C++初阶学习————类和对象（上）

C语言中是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++中是面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。并且面向对象有三大特性：封装、继承、多态。这里会先学到封装

类

初识类

在C语言中，结构体只能定义变量：

struct Data
{
	int day;
	int month;
	int year;
};

而在C++中也兼容这种写法，但更多时候用class来代替struct
类的定义及声明

class Data
{
	int day;
	int month;
	int year;
};

上面这种，class为定义类的关键字，Data为类的名字， { } 中为类的主体
与结构体不同的是，类还可以定义方法（函数）

class Data
{
	int day;
	int month;
	int year;

	void print()		在类体中定义类的方法（成员函数）
	{
		cout << year << "-" << month << "-" << day <<endl;
	}
};

需要注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
还有一种定义方法，在.h文件中声明，在.cpp中定义

调用时和结构体访问成员变量一样，只不过结构体是自己定义接口函数，把实例出来的结构体作为参数传给函数接口调用，类则直接引用自己类体里的成员函数就可以

int main()
{
	Stack a;
	a.Init();
	return 0;
}

类的访问限定符及封装

前面介绍的定义类的方法，还不完全，缺少了访问限定符，有了限定访问符就可以对类进行封装
C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
共有三个：

1. public修饰的成员在类外可以直接被访问（公有）
2. private修饰的成员在类外不能直接被访问（私有）
3. protected（保护）(此处protected和private是类似的)

访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
注意： class的默认访问权限为private，struct为public(因为struct要兼容C)，访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

class Data
{
private:
	int day;
	int month;
	int year;
public:
	void print()		
	{
		cout << year << "-" << month << "-" << day <<endl;
	}
};

这样类的简单定义就差不多了
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员，需要使用 :: 作用域解析符指明成员属于哪个类域。类似之前学习的namespace关键字，后面跟命名空间的名字。
例如上面
需要 ：：指定是属于哪个域的

类的实例化

如

class Data
{
private:
	int day;
	int month;
	int year;
public:
	void print()		
	{
		cout << year << "-" << month << "-" << day <<endl;
	}
};


int main()
{
	Stack a;
	a.Init();
	return 0;
}

1. 类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

这个a就是对类实例化出来的对象，可以理解为Data是个模板（或者建筑图纸），通过模板可以创建出很多相同的（建筑）

类对象的存储方式

假设实例化出多个对象

class Data
{
private:
	int day;
	int month;
	int year;
public:
	void print()		
	{
		cout << year << "-" << month << "-" << day <<endl;
	}
};


int main()
{
	Stack a;
	Stack b;
	Stack c;
	return 0;
}

实例化出来的这三个对象，他们的成员变量存的数据肯定是不一样的，但是他们的成员函数都是一样的，假如他们每个对象中的成员函数都占用内存，那相同的代码就会保存多份，这样就会浪费
所以在C++中，只保存成员变量，成员函数存放在公共的代码段

请看代码验证：

类中既有成员变量，又有成员函数
class A1 {
public:
 void f1(){}
private:
 int _a;
};

类中仅有成员函数
class A2 {
public:
 void f2() {}
};

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

可以看出保存形式类似结构体中的内存对齐，如A1中只有int，int占4字节，该类的最大对齐数就是4；
但是后面的A2、A3没有成员变量是空类，空类也占1字节。代表这个类是存在的。

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

this指针

先定义一个类

class Data
{
public:
	打印
	void Display ()
 	{
 		cout <<_year<< "-" <<_month << "-"<< _day <<endl;
 	}
 	赋值
 	void SetDate(int year , int month , int day)
 	{
 		_year = year;
 		_month = month;
 		_day = day;
 	}
 
private:
	int day;
	int month;
	int year;
};


int main()
{
	 Date d1, d2;
 	d1.SetDate(2018,5,1);
 	d2.SetDate(2018,7,1);
 	d1.Display();
 	d2.Display();
 	return 0; 
}

既然成员函数都是存在公共区（常量区代码段）的 ，那有这么个问题，当d1、d2调用成员函数是，怎么分辨是谁调用的呢？
所以C++中通过引入this指针解决该问题：
C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数， 让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

可以理解为如下代码

d1.SetDate(&d1,2018,5,1);
void SetDate(Date* const this,int year , int month , int day)
{
 	this->_year = year;
 	this->_month = month;
 	this->_day = day;
}

d2.Display(&d2);
void Display (Data* const this)
{
 	cout << this->_year << "-" << this>_month << "-"<< this->_day <<endl;
}

所以具体是看谁调用，就传谁给this

this指针的特性：

1. this指针的类型：类类型* const
2. 只能在“成员函数”的内部使用
3. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递、