面向对象语言的重头戏———类

我们知道C++是一门面向对象的语言，与面向过程的语言C不同的是C++的封装，继承和多态。而我们要介绍的类，也就是一种封装的思想，把相关元素和相关函数进行了包装，似的他们成为了一个整体，然后我们可以对整体进程处理。
下面举个例子，来帮助大家理解类的概念。我们开的小汽车，它有速度，油量，公里数，等等指标，把它们看做是数据元素，而左转，右转，刹车，加速等等操作看成是函数，那么我们的小汽车就是封装好的类。现在是不是有点点明白了呢？好下面正式介绍类的相关概念。

类的声明和定义

比如以我们讲的car为例

class car{//car 为类名
private://private表示私有数据（包括函数）
    double speed;
    double oil;
    double miles;
public://public表示公有数据（包括函数）
    void turnLeft(){};
    void turnRight(){};
    void brack(){};
    void accelerate(){};
};//注意这里有个分号

在这里我们定义了一个名叫car的类，就是是说我们造了一辆车，那么车里有什么东西呢？首先我们造了三个私有数据，然后造了四个公有函数。
好那么我们这里介绍一下private: public 以及protected(本例中未出现)
private顾名思义是说我们的数据或函数是类自己私有的，也就是说只有类自己的函数才能访问或者调用private修饰的数据或函数，外界是无法访问的。而public修饰的是公有的数据或函数，除了类自身可以用，我么在外部也可以访问到。protected关于到继承的概念，这里先不做讲解。
好了其实我们的car类已经可以使用了，我们先用一用,为了便于测试我们把speed元素设置成公有元素并赋初值为0，这样我们就能访问到来观察变化

class car{//car 为类名
private://private表示私有数据（包括函数）
    double oil;
    double miles;
public://public表示公有数据（包括函数）
    double speed=0;
    void turnLeft(){};
    void turnRight(){};
    void brack(){};
    void accelerate(){};
};//注意这里有个分号

使用car类

#include<iostream>
using namespace std;
class car{
private:
    double oil;
    double miles;
public:
    double speed = 0;
    void turnLeft(){};
    void turnRight(){};
    void brack(){};
    void accelerate(){ speed++; };
};

int main(){
    car car1;
    cout << car1.speed << endl;
    car1.accelerate();
    cout << car1.speed << endl;
    car1.accelerate();
    cout << car1.speed << endl;
    car1.accelerate();
    cout << car1.speed << endl;
}

Paste_Image.png

哈哈，看到没？我们用car类实例化了一辆车，名字叫car1，然后初始状态下它的速度是0，然后我们调用了car1车的accelerate函数（因为被修饰为public，所以能访问），结果它的速度加了1，在调用accelerate函数，速度又加1，所以我们的车就动起来了。现在你是不是对封装有了新的认识呢？
关于类的只是远不止这些，其实我们上例中的的函数有6个，除了我们定义的4个之外，还有一个默认构造函数，和一个默认析构函数。那么什么是构造函数，什么又是析构函数呢？

构造函数

我们可以这样理解，当我们初始化一辆车的时候，并不是每次想要的都是同一种车，也许我们想要它的速度是0，但我们也可以设置它的初始速度为100，所以我们就要对构造函数进行重新定义，看下面这个例子

class car{
private:
    double oil;
    double miles;
public:
    double speed = 0;
    car(){};//构造函数，没有返回值类型，名字与类名一样
    car(double s){ speed = s; };//构造函数，这里是重载
    void turnLeft(){};
    void turnRight(){};
    void brack(){};
    void accelerate(){ speed++; };
};

ok，这里我们给出了两个构造函数，第一个似乎什么也没干，没错，这就是默认的构造函数，但是为什么要写出来呢？因为一旦我们定义了构造函数，系统就不在给我们提供默认的构造函数，所以当我们要用到这个什么也不干的构造函数时，就要写出来啦。那么第二个构造函数，car(double s){ speed = s; };这里我们设置了speed的值，有人会问为什么两个函数的名字一样？这里简单解释一下，这叫做函数的重载，也就是说函数名一样但是函数的参数列表不一样，或者返回值类型不一样。当我们调用函数的时候，系统会比对我们需要调用的函数的形式，自动选择相应的函数，看下例：

#include<iostream>
using namespace std;
class car{
private:
    double oil;
    double miles;
public:
    double speed = 0;
    car(){};//构造函数，没有返回值类型，名字与类名一样
    car(double s){ speed = s; };//构造函数，这里是重载
    void turnLeft(){};
    void turnRight(){};
    void brack(){};
    void accelerate(){ speed++; };
};

int main(){
    car car1;//注意，当构造函数的参数为0是，只需要写出函数名即可，而不写成car()的形式
    car car2(100);
    cout << "car1 的速度是：" << car1.speed << endl;
    cout << "car2 的速度是：" << car2.speed << endl;
}

Paste_Image.png

聪明的你发现了米有，我们使用的是同一个类，却实例化了初始状态不同的两辆车。这句是我们构造函数所起的作用。

析构函数

讲过了构造函数，我们来看一下析构函数的概念。析构函数相当于毁掉你一手创建的东西，也就是说，如果把构造函数看成是打造一辆“莱肯”超跑的话，那么析构函数就像《速度与激情7》中的Tom把超跑横穿三栋大厦之后坠落毁成烂泥一样！没错，也就是把你辛苦创建的东西给彻底毁掉。那么你该说了，为什么要有析构函数呢？这么凶残的函数！哈哈，确实，有时候，我们只需要一个东东存在一段时间，然后就不在需要了，那么我们为了节省内存，只能将其毁掉。析构函数的写法与构造函数类似，只是在函数名前面加了一个 `这个符号是键盘tab键上面的那个，别忘了按住shift键。是析构函数是系统自动调用的，下面来看一下，什么时候会调用析构函数。

#include<iostream>
using namespace std;
class car{
private:
    double oil;
    double miles;
public:
    double speed = 0;
    car(){};//构造函数，没有返回值类型，名字与类名一样
    car(double s){ speed = s; };//构造函数，这里是重载
    ~car(){ cout << "这里调用了析构函数，本车的速度是" << speed << endl; };
    void turnLeft(){};
    void turnRight(){};
    void brack(){};
    void accelerate(){ speed++; };
};

int main(){
    car car1;//注意，当构造函数的参数为0是，只需要写出函数名即可，而不写成car()的形式
    car car2(100);
    car car3(200);
    car car4(300);
    car car5(400);
    cout << "car1 的速度是：" << car1.speed << endl;
    cout << "car2 的速度是：" << car2.speed << endl;
}

Paste_Image.png

没错我们并没有刻意调用析构函数，但是当我们的程序要结束的时候，系统自动调用了析构函数，来释放空间，也就是说我们的超跑就要成为一堆废铁了，细心的会你发现为什么析构函数和构造函数的调用次序相反呢？
这篇文章给了简单的说明http://blog.sina.com.cn/s/blog_705460410102wq08.html

以上我们成员函数的实现都是在类体当中，这样如果我们的函数很复杂，就会使得我们的类变得很臃肿，不能够很清晰的观察类的结构，所以我们有另一种写法，就是在类中声明函数而不实现，具体的定义部分在类之外完成，看下面的例子：

class car{
private:
    double oil;
    double miles;
public:
    double speed = 0;
    car();//构造函数，没有返回值类型，名字与类名一样
    car(double s);//构造函数，这里是重载
    ~car();
    void turnLeft();
    void turnRight();
    void brack();
    void accelerate();
};

//成员函数的实现

//构造函数
car::car(){};
car::car(double s){ speed = s; };
//析构函数
car::~car(){ cout << "这里调用了析构函数，本车的速度是" << speed << endl; };
//其他成员函数
void car::turnLeft(){};
void car::turnRight(){};
void car::brack(){ speed = 0; };
void car::accelerate(){ speed++; };

我们在类中只是声明了一些函数，具体的实现放在了外面，为了表示出是哪个类的成员函数，我们通过类名::函数名（参数列表）{...}的形式来定义函数，不要忘了写函数的返回值类型，返回值类型一定要放在最前面。
学习了这一小节，我们应该达到的目标是，对C++的封装的设计理念有一定的了解，要会类的简单实用。对私有数据和函数，以及公有数据和函数有一定的理解和区分。
下一小节，我们将介绍模板函数的概念和使用。