当前位置：天才代写 > tutorial > C语言/C++ 教程 > C++中类的担任特性

C++中类的担任特性

2017-11-05 08:00 星期日 所属： C语言/C++ 教程 浏览：370

副标题#e#

整个c++措施设计全面环绕面向工具的方法举办，类的担任特性是c++的一个很是很是重要的机制，担任特性可以使一个新类得到其父类的操纵和数据布局，措施员只需在新类中增加原有类中没有的身分。

可以说这一章节的内容是c++面向工具措施设计的要害。

下面我们简朴的来说一下担任的观念，先看下图:

C++中类的接受特性

上图是一个抽象描写的特性担任表

交通东西是一个基类（也称做父类），凡是环境下所有交通东西所配合具备的特性是速度与额定载人的数量，但凭据糊口通例，我们来继承给交通东西来细分类的时候，我们会别离想到有汽车类和飞机类等等，汽车类和飞类同样具备速度和额定载人数量这样的特性，而这些特性是所有交通东西所共有的，那么当成立汽车类和飞机类的时候我们无需再界说基类已经有的数据成员，而只需要描写汽车类和飞机类所特有的特性即可，飞机类和汽车类的特性是由在交通东西类原有特性基本上增加而来的，那么飞机类和汽车类就是交通东西类的派生类（也称做子类）。以此类推，层层递增，这种子类得到父类特性的观念就是担任。

下面我们按照上图的领略，有如下的代码：

#include <iostream>
using namespace std;
class Vehicle
{
public:
    void EditSC(float speed,int total);
protected:
    float speed;//速度
    int total;//最大载人量
};
void Vehicle::EditSC(float speed,int total)
{
    Vehicle::speed = speed;
    Vehicle::total = total;
}
class Car:public Vehicle//Car类担任Vehicle的特性，Car类是Vehicle的派生类
{
public:
    Car()
    {
        aird=0;
    }
protected:
    int aird;//排量
};
class plane:public Vehicle
{
protected:
    float wingspan;//翼展
};
void main()
{
    Car a;
    a.EditSC(150,4);
    cin.get();
}

派生类的界说可以在类名称后加冒号public空格加基类名称举办界说，如上面代码中的class Car:public Vehicle。


#p#副标题#e#

一旦乐成界说派生类，那么派生类就可以操纵基类的所有数据成员包罗是受掩护型的，上面代码中的a.EditSC(100,4); 就是例子，甚至我们可以在结构派生类工具的时候初始化他们，但我们是不推荐这么做的,因为类于类之间的操纵是通过接口举办串连的，为了不粉碎类的这种封专装特性，纵然是父类于子类的操纵也应按遵循这个思想，这么做的长处也是显而易见的，当基类有错的时候，只要不涉及接口，那么基类的修改就不会影响到派生类的操纵。

C++中类的接受特性

至于为什么派生类可以或许对基类成员举办操纵，我们上图可以简朴的说明基类与子类在内存中的分列状态。

我们知道，类工具操纵的时候在内部结构的时候会有一个隐的this指针，由于Car类是Vehicle的派生类，那么当Car工具建设的时候，这个this指针就会包围到Vehicle类的范畴，所以派生类可以或许对基类成员举办操纵。

笔者写到这里的时候不得不提一下，我有开拓c#与java的履历，就这两种语言来说，学到这里的时候许多人很难领略担任这一部门的内容，可能是领略的恍惚不清，其实正是缺少了与this指针相关的c++常识，大都高级语言的特性是不涉及内存状态的操纵，java与c#是打仗不到这些常识的，所以领略起这部门内容就更抽象更不详细。

下面我们来说一下,派生类工具(子类工具)的结构。

由上面的例程我们知道Car类是Vehicle类的派生类(子类)，c++划定，建设派生类工具的时候首先挪用基类的结构函数初始化基类成员，随后才挪用派生类结构函数。

可是要留意的是，在建设派生类工具之前，系统首先确定派生类工具的包围范畴（也可以称做巨细尺寸），上面代码的派生类工具a就包围于Vehicle类和Car类上，至于派生类工具的建设是如何结构基类成员的，我们看如下代码，随后再举办阐明：

#p#副标题#e#

#include <iostream>
using namespace std;
class Vehicle
{
public:
    Vehicle(float speed=0,int total=0)
    {
        cout<<"载入Vehicle类结构函数"<<endl;
        Vehicle::speed = speed;
        Vehicle::total = total;
    }
    Vehicle(Vehicle &temp)
    {
        Vehicle::speed = temp.speed;
        Vehicle::total = temp.total;
    }
    ~Vehicle()
    {
        cout<<"载入Vehicle类析构函数"<<endl;
        cin.get();
    }
protected:
    float speed;//速度
    int total;//最大载人量
};
class Car:public Vehicle
{
public:
    Car(float aird=0,float speed = 0,int total = 0):Vehicle(speed,total)
    {
        cout<<"载入Car类结构函数"<<endl;
        Car::aird = aird;
    }
    Car(Car &temp):Vehicle(temp.speed,temp.total)
    {
        cout<<"载入Car类拷贝结构函数"<<endl;
        Car::aird = temp.aird;
    }
    ~Car()
    {
        cout<<"载入Car类析构函数"<<endl;
        cin.get();
    }
protected:
    float aird;//排量
};
void main()
{
    Car a(250,150,4);
    Car b = a;
    cin.get();
}

#p#分页标题#e#

工具a建设的时候通过Car(float aird = 0,float speed = 0,int total = 0):Vehicle(speed,total)，也就是Car类结构函数，来结构Car类工具成员，但凭据c++的划定首先应该挪用基类结构函数结构基成员，在这里基类成员的结构是通过Vehicle(speed,total)，来实现的。

#p#副标题#e#

但值得留意的是Vehicle(speed,total)的意义并不是对Vehicle类的个个成员的初始化，事实上是操作它建设了一个Vehicle类的无名工具，由于Car类工具的包围范畴是包围于Vehicle类和Car类上，所以系统在确定了派生类工具a的空间范畴后，确定了this指针位置，这个this指针指向了Vehicle类的谁人无名工具,这个成员赋值进程就是，this->speed＝无名工具.speed。

其实这里观念较量恍惚，笔者因为小我私家本领的原因临时也无法说的更明晰了，读者对此处常识点的进修，应该靠本身多比拟多操练，举办体会领略。

很多书籍对付派生类工具的复制这一常识点多是空白的，为了教程的易读性，我照旧抉择说一下在复制进程中容易堕落的处所，Car b=a;是派生类工具复制的语句，通过前面教程的进修我们我们知道，类工具的复制是通过拷贝结构函数来完成的，假如上面的例子我们没有提供拷贝结构函数不完整如下：

Car(Car &temp)
{
    cout<<"载入Car类拷贝结构函数"<<endl;
    Car::aird = temp.aird;
}

那么复制进程中就会丢失基类成员的数据了，所以Car类拷贝结构函数不能缺少Vehicle类无名工具的建设进程:Vehicle(temp.speed,temp.total)，派生类工具的复制进程系统是不会再挪用基类的拷贝结构函数的，this指针的问题再次在这里浮现出来，各人可以实验着把无名工具的建设去掉，调查b.speed的变革。

类工具够建设一定就有析构进程，派生类工具的析构进程首先是挪用派生类的析构进程，再挪用基类的结构函数，正好和建设进程相反，在这里笔者已经在上面代码中插手了进程显示，读者可以自行编译后调查。

最后我们说一下类的担任与组合。

#p#副标题#e#

其实类的组合我们在早些的前面的教程就已经打仗过，只是在这里换了个说法罢了，当一个类的成员是另一个类的工具的时候就叫做组合，事实上就是类于类的组合。组合和担任是有明明别离的，为了充实领略担任与组合的干系，我们在不粉碎类的封装特性的环境下，先看如下的代码：

#include <iostream>
using namespace std;
class Vehicle
{
public:
    Vehicle(float speed=0,int total=0)
    {
        Vehicle::speed = speed;
        Vehicle::total = total;
    }
protected:
    float speed;//速度
    int total;//最大载人量
};
class Motor
{
public:
    Motor(char *motor)
    {
        Motor::motortype = motor;
    }

    char* SMT(Motor &temp);
protected:
    char *motortype;//动员机型号
};
char* Motor::SMT(Motor &temp)
{
    return temp.motortype;
}
class Car:public Vehicle//担任的浮现
{
public:
    Car(float speed,int total,int aird,char *motortype):Vehicle(speed,total),motor(motortype)
    {
        Car::aird = aird;
    }
    Motor rm(Car &temp);
protected:
    int aird;//排量
    Motor motor;//类组合的浮现
};
Motor Car::rm(Car &temp)
{
    return temp.motor;
}
//--------------------------------------------------------------
void test1(Vehicle &temp)
{
    //中间进程省略
};
void test2(Motor &temp)
{
    cout<<temp.SMT(temp);//读者这里留意一下,temp既是工具也是工具要领的形参
}
//--------------------------------------------------------------
void main()
{
    Car a(150,4,250,"奥地利AVL V8");
    test1(a);
    //test2(a);//错误,Car类与Motor类无任何担任干系
    test2(a.rm(a));//假如Car类成员是public的那么可以利用test2(a.motor)
    cin.get();
}

#p#分页标题#e#

在上面的代码中我们新增加了动员机类Motor，Car类增加了Motor范例的motor成员，这就是组合，拥有担任特性的派生类可以操纵基类的任何成员，但对付与派生类组合起来的普通类工具来说，它是不会和基类有任何接洽的。

函数挪用：test1(a);，可以乐成执行的原因就是因为Car类工具在系统是看来一个Vehicle类工具，即Car类是Vehicle类的一种，Car类的包围范畴包括了Vehicle。

函数挪用：test2(a);，执行错误的原因是因为Motor类并不承认Car类工具a与它有任何关系，但我们可以通过利用Car类工具a的Motor类成员motor，作为函数形参的方法来挪用test2函数（test2(a.motor)），在这里由于类的成员是受掩护的所以我们操作a.rm(a)来返回受掩护的motor，作为函数参数举办挪用。

 

    关键字：

天才代写-代写联系方式