类和对象（上）
一、类的定义
1.1类定义的格式
class为定义类的关键字，Stack为类的名字，{ }中为类的主体，注意类定义结束时后面分号不能省略。
#include
using namespace std;
//定义一个类名为Stack的类
class Stack
{
public:
//成员函数：
int ADD()
{
return _key+_value;
}
private:
//成员变量：
int _key;
int _value;
}; 类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。
为了区分成员变量，⼀般习惯上成员变量会加⼀个特殊标识，如成员变量前⾯或者后⾯加_ 或者m但这也不是强制性的，具体看要求。
C++中struct 也可以定义类，C++兼容C中struct的⽤法，同时struct升级成了类，明显的变化是struct中可以定义函数，但是一般情况下我们还是推荐用class定义类。
定义在类里面的函数默认为inline。
1.2 访问限定符
C++⼀种实现封装的⽅式，⽤类将对象的属性与⽅法结合在⼀块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
public修饰的成员在类外可以直接访问，而protected和private修饰的成员在类外是不可以直接访问的，private和protected是一样的，后续继承才能体现出它们的区别。
#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;
class Stack
{
public:
//成员函数：
int ADD() //这里成员函数用public修饰故可以在类外访问
{
return _key + _value;
}
Stack(int key,int value)
{
_key = key;
_value = value;
}
private:
//成员变量：
int _key;
int _value;
};
int main()
{
Stack d1(6,9);
int ret = d1.ADD(); //访问public成员
cout << ret << endl;
return 0;
} 如果直接在类外访问private或protected修饰的成员就会出现以下类似报错：
class Stack
{
public:
//构造函数：
Stack(int key,int value)
{
_key = key;
_value = value;
}
private:
//成员变量：
int _key;
int _value;
};
int main()
{
Stack d1(6,9);
d1._key=10;
return 0;
} 
class定义的成员没有访问限定符修饰时默认为private,而struct默认为public，一般情况下我们用class定义类成员变量会被限制为private或protected，需要给别人使用的成员函数会被放为public。
1.3 类域
类定义了一个新的作用域，类的所有成员都在类的作用域中，在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域。
例如：我们在进行成员函数的声明与定义分离时需要指定类域：
string.h文件
//string.h 文件
#define _CRT_SECURE_NO_WARNINGS
#pragma once
#include
#include
using namespace std;
namespace yue
{
class string
{
public:
string(const char* str="")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str,str);
}
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
//三个成员函数的声明
void reserve(size_t n);
void push_back(char ch);
void append(const char* str);
private:
char* _str;
size_t _size;
size_t _capacity;
}; string.cpp文件
#include"string.h"
namespace yue
{
void string::reserve(size_t n)
{
if (n > _capacity)
{
char* temp = new char[n + 1];
strcpy(temp,_str);
delete[] _str;
_str = temp;
_capacity = n;
}
}
void string::push_back(char ch)
{
if (_size == _capacity)
{
reserve(_capacity==0?4:2*_capacity);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
void string::append(const char* str)
{
size_t len = strlen(str);
if (_size+len>_capacity)//说明空间不够了
{
reserve(_size+len>2*_capacity?_size+len:2*_capacity);
}
strcpy(_str+_size,str);
_size += len;
}
}二、类的实例化
2.1 实例化的概念
用类类型在物理内存中创建对象的过程，称为类实例化出对象。
类是一种抽象的描述，是一个模型一样的东西，限定了类有哪些成员变量，这些成员变量只是声明没有分配空间，只有在实例化出对象的时候才会分配空间。
一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量。打个比方：类实例化出对象就像现实中使⽤建筑设计图建造出房⼦，类就像是设计图，设计图规划了有多少个房间，房间大小功能等，但是并没有实体的建筑存在，也不能住⼈，⽤设计图修建出房⼦，房⼦才能住⼈。同样类就像设计图⼀样，不能存储数据，实例化出的对象分配物理内存存储数据。
class Date
{
public:
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;
return 0;
}这里需要注意的一点是：
如果类中没有定义成员变量（是否定义成员函数无所谓因为成员函数不需要存储在对象之中） ，所定义出来对象的大小为1而不是0，这里1纯粹为了占位无实际意义。
2.2 对象的大小
类示例化出对象之后我们如何判断对象大小呢？首先成员变量是一定被包含在对象之中的，我们要考虑的是成员函数：
首先函数编译后是一段指令，对象之中没办法存储，这些指令存储在一个单独的区域（代码段），那么对象之中非要存储的话只能是成员函数的指针。这就说明当类实例化出多个对象时成员函数的指针就会多次重复存储太浪费了，所以成员函数指针不需要存储在对象之中。函数指针是一个地址，调用函数时被编译成汇编指令（call 地址），其实编译器在编译链接的时候，就要找到函数的地址而不是在运行时找，只有动态多态是在运行时找，就需要存储函数地址。
上面我们分析了实例化出的对象之中只存储成员变量，C++规定成员变量在对象之中的存储也要符合内存对齐原则：
内存对齐原则:
- 第一个成员在结构体偏移量为0的地址处
- 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
- 对齐数=编译器默认的一个对齐数与该成员大小的较小值
- VS中默认的对齐数为8
- 结构体总大小为：最大对齐数的整数倍
- 如果嵌套了结构体的情况，嵌套结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数的整数倍
#include
using namespace std;
class Date
{
public:
void Init(int year, int month, int day)
{
cout << "hello world" << endl;
}
private:
char _a;
int _i;
};
int main()
{
Date d1;
cout << sizeof(d1) << endl;
return 0;
} 这里要计算对象d1的大小首先成员函数 Init 不占有空间我们不涉及，根据内存对齐原则char类型的_a 先在地址为0位置处，要计算_i变量的对齐数，因为4<8（4为int类型变量大小）所以_i的对齐数为4 故该类类型实例化出的对象大小为8。
如下图：
代码运行结果如下：
2.3 this 指针
Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调⽤Init和Print函数时，该函数是如何知道应该访问的是d1对象还是d2对象呢？那么这⾥就要看到C++给了⼀个隐含的this指针解决这里的问题。
编译器编译后，类的成员函数默认都会在形参的第一个位置，增加一个当前类类型的指针，叫做this指针。比如Date类的Init的真实原型是：
void Init (Date * const this, int year , int month ， int day )
类的成员函数中访问成员变量时，本质上都是通过 this指针访问的 ，如Init函数中给_year赋值：this->_year=year。
C++规定不可以在形参和实参的位置显示地写this指针，但是可以在函数体内显示地使用this指针。
#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;
class Date
{
public:
//真实原型是void Init(Date* const this,int year,int month,int day)
//在成员函数中this指针被省略了
void Init(int year, int month, int day)
{
_year = year; //也可以写成 this->_year=year;
_month = month;//this->_month=month;
_day = day; //this->_day=day;
}
void Print()
{
cout << _year << '/' << _month << '/' << _day<