什么是类？什么是对象？不得不提到面向对象的编程风格，类就是C++为了实现面向对象对象而存在的，与C语言面向过程的编程风格不同的地方就是面向对象的编程风格关注的是对象，而面向过程的编程风格关注的是完成这件事的过程，分析求解问题的步骤，通过一个一个函数逐步解决问题。详细可见从C语言的面型对象风格编程过度理解面向对象风格编程。（通过这篇文章，你可以很清晰理解封装，继承三大特性，且是从C语言角度进行说明，还不懂类和对象相关知识也可以瞧一瞧。）
前言：
C语言的结构体中只能定义变量，而在C++中，结构体不仅可以定义变量，还可以定义函数，正如在上边介绍的文章中，在结构体内存放的只是函数的指针，通过调用函数指针执行相关的函数，而现在，我们可以直接将函数放在结构体中。
小李子演示一下
C++将方法和数据结合在一起，创造一个类，直接调用该类所构造的方法实现某些功能，我们只需要调用就可以了，不需要在乎内部如何实现。（关于C++类的奥妙才刚开始）
上边案例为了方便没有分文件来写，下边会详细展开。
类的结构和定义
和结构体相仿（毕竟是为了兼容C）,如下
class classname//类名
{
//类体：有成员变量和成员数组成
};
在C++中，struct和class作用一样，在C++中更喜欢用class(类)来代替。不同的是struct定义的类默认是公开的(public)，而class定义的类默认是私有的（private）。
什么是public和private呢？
这就又要谈到类的访问限定符
访问限定符可以决定类中那些函数可以被调用，那些不可以，也可以保护类中定义的变量不被外界随机修改导致错误。
访问限定符有以下几种：
【访问限定符说明】
- public修饰的成员在类外可以直接被访问
- private和protected修饰的成员函数或成员变量不可以被直接访问。（他们的区别先不要计较啦，后边会讲）
- 访问限定符作用域从该访问限定符出现的位置到下一个访问限定符出现为止。
- 如果一个访问限定符后边没有限定符存在了，那作用域就是整个类。
- class的默认访问权限是private，而struct的默认访问权限是public（兼容C，两次提到啦，要记住哦）。
类的作用域
类定义了一个新的作用域，类的所有成员都在类的作用域中。再类外定义成员时，需要使用::作用域操作符指明成员属于哪个类域。（和命名空间一样）
举个例子更清晰
class Person
{
public://冒号哦
void PrintPersonInfo();
private:
char _name[20];
char _gender[3];
int _age;
};
void Person::PrintPersonInfo()
{
cout << _name << " " << _gender << " " << _age << endl;
}
类的实例化
类是用来描述对象的，类的声明就是构造出这个对象的模型，就像建造房子时需要的图纸，类的实例化的过程就是用这个图纸建造房子，图纸是不需要占空间的，而用类类型创建对象后，创建的对象要占用实际的物理空间。
一个类可以实例化出多个对象，就像有一张图纸，可以建造许多一模一样的房子一样，实例化的对象占有实际的物理空间，从而储存内部成员变量及成员函数。
那图纸有空间吗？答案是没有，如何验证呢？
类对象的大小
如何计算类对象的大小呢？类中既有成员函数，又有成员变量，成员函数占内存吗？占多少呢？
验证一下
可以发现，类和结构体一样，都要进行内存对齐，而且类中的函数是不占大小的。
这是为什么呢？
如果一个类实例化出的多个对象中的函数实现的功能相同，然而占用不同的空间，会增加很多的内存开销，解决方法就是将成员函数的代码放在公共的代码段，每个对象调用时在公共代码段就可以调用到该函数，减小内存开销。
有关结构体大小及内存对齐规则有疑惑的可以看一看热门题型结构体大小的计算。
this指针的引出
就这个，如果我实例化出了好多好多对象，p1,p2,p3,p4等等等等。
每个人的age赋值不一样，那么每个对象调用打印他的年龄时如何分辨呢？函数的内容全部都一样啊，如何分辨呢？
疑惑
C++就引入了this指针解决该问题。
C++给每个非静态的成员函数增加了一个隐藏的指针参数，该指针指向当前对象（函数调用时调用该函数的对象），在函数体中所有“成员变量”的操作，都是通过该指针进行访问的，只不过这些操作对用户是透明的，用户不需要传递，编译器自动完成。还记得上边所写的用C语言模拟实现该过程，不得不传递一个类变量过去，C++相较于C而言，很多事都交给了编译器去做，这就是C++方便的地方（当然还有很多奥妙，后边你才会体会到C++的方便和好用）。
this指针的特性
- this指针的类型：类类型（类的类型，即类名）*const，不可以改变this哦。
- this指针本质是成员函数的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参，所以对象中不存储this指针。
- this指针只能在成员函数的内部使用
- this指针是成员函数第一个隐含的指针形参，一般情况下右编译器通过ecx寄存器自动传递，不需要用户传递。
不需要用户传递，隐含的this指针我们也可以写出来，还可以做返回值。
class Person
{
public:
void Print()
{
cout << this->_age << endl;
}
int _age;
char a;
};
int main()
{
Person p1;//实例出对象p1，才有实际的成员
p1._age = 10;
p1.Print();
cout << sizeof(p1) << endl;
return 0;
}
现在我们用一个例子对照C和C++实现stack的不同，帮助我们更好理解C++面向对象的编程风格和面向过程的编程风格之间的区别。
typedef int DataType;
typedef struct Stack
{
DataType* array;
int capacity;
int size;
}Stack;
void StackInit(Stack* ps)
{
assert(ps);
ps->array = (DataType*)malloc(sizeof(DataType) * 3);
if (NULL == ps->array)
{
assert(0);
return;
}
ps->capacity = 3;
ps->size = 0;
}
void StackDestroy(Stack* ps)
{
assert(ps);
if (ps->array)
{
free(ps->array);
ps->array = NULL;
ps->capacity = 0;
ps->size = 0;
}
}
void CheckCapacity(Stack* ps)
{
if (ps->size == ps->capacity)
{
int newcapacity = ps->capacity * 2;
DataType* temp = (DataType*)realloc(ps->array,
newcapacity * sizeof(DataType));
if (temp == NULL)
{
perror("realloc申请空间失败!!!");
return;
}
ps->array = temp;
ps->capacity = newcapacity;
}
}
void StackPush(Stack* ps, DataType data)
{
assert(ps);
CheckCapacity(ps);
ps->array[ps->size] = data;
ps->size++;
}
int StackEmpty(Stack* ps)
{
assert(ps);
return 0 == ps->size;
}
void StackPop(Stack* ps)
{
if (StackEmpty(ps))
return;
ps->size--;
}
DataType StackTop(Stack* ps)
{
assert(!StackEmpty(ps));
return ps->array[ps->size - 1];
}
int StackSize(Stack* ps)
{
assert(ps);
return ps->size;
}
int main()
{
Stack s;
StackInit(&s);
StackPush(&s, 1);
StackPush(&s, 2);
StackPush(&s, 3);
StackPush(&s, 4);
printf("%d\n", StackTop(&s));
printf("%d\n", StackSize(&s));
StackPop(&s);
StackPop(&s);
printf("%d\n", StackTop(&s));
printf("%d\n", StackSize(&s));
StackDestroy(&s);
return 0;
}
观察可以发现C语言实现时，Stack相关的函数都有一下共性：
- 每个函数的第一个参数都要是Stack*.
- 函数中必须要对第一个参数检测，因为该参数可能会为NULL。
- 函数中都是通过Stack*参数操作栈的。
- 调用时必须传递Stack结构体变量的地址。
结构体只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相对复杂一点，涉及到大量指针操作，稍不注意可能就会出错。
C++写法
typedef int DataType;
class Stack
{
public:
void Init()
{
_array = (DataType*)malloc(sizeof(DataType) * 3);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = 3;
_size = 0;
}
void Push(DataType data)
{
CheckCapacity();
_array[_size] = data;
_size++;
}
void Pop()
{
if (Empty())
return;
_size--;
}
DataType Top() {
return _array[_size - 1]; }
int Empty() {
return 0 == _size; }
int Size() {
return _size; }
void Destroy()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
void CheckCapacity()
{
if (_size == _capacity)
{
int newcapacity = _capacity * 2;
DataType* temp = (DataType*)realloc(_array, newcapacity *sizeof(DataType));
if (temp == NULL)
{
perror("realloc申请空间失败!!!");
return;
}
_array = temp;
_capacity = newcapacity;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
Stack s;
s.Init();
s.Push(1);
s.Push(2);
s.Push(3);
s.Push(4);
printf("%d\n", s.Top());
printf("%d\n", s.Size());
s.Pop();
s.Pop();
printf("%d\n", s.Top());
printf("%d\n", s.Size());
s.Destroy();
return 0;
}
C++通过类将数据和方法（函数）进行结合，通过访问权限可以控制哪些方法或变量可以在类外进行调用，这就是封装。
在使用时每个函数不需要传递Stack的参数了，编译器在编译后会自动还原。C++中的Stack参数是有编译器维护的，C语言需要自己进行维护。
可以对照比较函数的不同。
