C++语言类之间的关系

在c++中通过类定义对象，而类与类之间也有着复杂的关系，所以题外话，我能理解到c++的编写者可能就想通过计算机语言去模拟世界万物之间的关系，这篇帖子主要从横向和纵向去讨论类之间关系

而在一个类中想要使用另一个类中的内容，无非三种方式，1.直接传参 2.传地址 3.在一个类中去定义另一个类

从横向来看，可以分为1.依赖 2.关联 3.聚合 4.复合，接下来用UML类图展示一下这几种横向关系

 第一种，依赖，一个对象的一个功能需要依赖另一个对象存在，被依赖的对象作为工具使用，   在上图的例子中，CComputer 这个类对于CPerson来说，是作为Coding的一个工具，CComputer不是CPerson的一个特性，所以是依赖关系

第二种，关联，就类似于朋友之间的平等关系，关联的特点是随时建立，随时解除，利用指针去指向CFriend的地址

第三种，聚合，相当于强版本的关联，但聚合的目的是为了统一进行管理同类型的对象，就像是一个家庭，或者是一个班级，所以一般这里的对象都需要new出来的， 在聚合的析构里可以统一删除，统一创建

第四种，复合，又叫组合，是属于CPerson的一部分，类似于脑袋，双手

之所以建立这种类之间的关系，也是根据c++的单一性这个特点，每一个部分都是一个独立的个体，一个类的修改不会影响到其他的部分，也可以进行任意组合，下面是针对这个类图的代码

#include <iostream>
#include <time.h>
using namespace std;


class CHead
{
public:
    void Say()
    {
        cout << "张个大嘴，哇啦哇啦" << endl;
    }
};

class CHand
{
public:
    void Move()
    {
        cout << "比比划划" << endl;
    }
};

class CComputer
{
public:
    void Coding()
    {
        cout << "C++ Coding....." << endl;
    }
};

class CFriend
{
public:
    int rp;
public:
    CFriend()
    {
        rp = rand()%10;
    }
public:
    void Play()
    {
        cout << "哈哈哈哈哈哈" << endl;
    }
};



class CPerson
{
public:
    CHead head;    //  组合
    CHand hand;
    CFriend* m_pFriend;   //  关联一个朋友
public:
    CPerson()
    {
        m_pFriend = 0;
    }
public:
    void FindFriend(CFriend* pFriend)
    {
        if(pFriend == 0)
            return;

        if(pFriend->rp > 4)
        {
            m_pFriend = pFriend;
        }
    }
    void ChickenDinner()
    {
        if(m_pFriend == 0)
        {
            cout << "~~~~(>_<)~~~~玩的不开心" << endl;
        }
        else
        {
            m_pFriend->Play();
        }
    }
    void Say()
    {
        head.Say();
        hand.Move();
    }
    void Coding(CComputer& cm)   //  依赖一个电脑
    {
        head.Say();
        cm.Coding();
    }
};



class CFamily
{
public:
    CPerson* pArr[5];    //  聚合到 家庭中
public:
    CFamily()
    {
        for(int i=0;i<5;i++)
            pArr[i] = 0;
    }
    ~CFamily()
    {
        for(int i=0;i<5;i++)
        {
            if(pArr[i] != 0)
            {
                delete pArr[i];
                pArr[i] = 0;
            }
        }
    }
public:
    void PushPerson(CPerson* ps)
    {
        if(ps == 0)
            return;
        for(int i=0;i<5;i++)
        {
            if(pArr[i] == 0)
            {
                pArr[i] = ps;
                return;
            }
        }
    }
    void AllPersonCoding(CComputer& cm)
    {
        for(int i=0;i<5;i++)
        {
            if(pArr[i] != 0)
            {
                pArr[i]->Coding(cm);
            }
        }        
    }
};




int main()
{

    //srand((unsigned int)time(0));

    //CComputer cm;
    //CFriend ff;

    //CPerson ps;
    //ps.Say();
    //ps.Coding(cm);

    //ps.FindFriend(&ff);
    //ps.ChickenDinner();

    //--------------------------------------------------
    CPerson* ps1 = new CPerson;
    CPerson* ps2 = new CPerson;
    CPerson* ps3 = new CPerson;

    CComputer cm;
    CFamily fm;
    fm.PushPerson(ps1);
    fm.PushPerson(ps2);
    fm.PushPerson(ps3);
    fm.AllPersonCoding(cm);

    system("pause");
    return 0;
}

而从纵向关系来看的关系有1.继承 2.多态

首先来说继承，继承中分为基类（父类），派生类（子类），继承的优点就是，提高代码的复用性，在派生类中，基类的所有成员都可以使用，而具体能否使用就得看继承的方式了

a.public继承，子类，public不变，protected不变，private变成不可访问的

b.protected 继承，子类，public->protected, protected不变, private变成不可访问的

c.private继承，子类，public->private, protected->private，private变成不可访问的

而需要注意的两点是

1. 继承的方式影响的是派生类的派生类
2. 继承的方式影响的只是基类的成员，不影响本类的访问修饰符

继承中还有一点就是继承关系的构造析构

1. 继承里子类构造的初始化列表里默认为父类的初始化（很重要的一点）
2. 局部顺序

子类构造->子类初始化列表->完成父类构造->完成子类构造->完成子类析构->回收子类空间->完成父类析构(在虚析构当中，虚函数完成的只是通过父类析构找到子类析构的过程，之后的过程和这个是一样的)

做一个小实验可以很好的看出来顺序

#include<iostream>
using namespace std;

class CPerson
{
public:
    CPerson()
    {
        cout << "CPerson()" << endl;
    }
    ~CPerson()
    {
        cout << "~CPerson()" << endl;
    }
};
class CSon : public CPerson
{
public:
    CSon()
    {
        cout << "CSon" << endl;
    }
    ~CSon()
    {
        cout << "~CSon" << endl;
    }
};
int main()
{
    {
        CSon cs;
    }



    system("pause");
    return 0;
}

第二个，多态，可以看一下上一篇帖子里 对于多态的讨论

2019-05-30 11:31:45 编程小菜鸟自我反思，大家可以留下自己的建议和意见，谢谢！！！