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()%;
     }
 public:
     void Play()
     {
         cout << "哈哈哈哈哈哈" << endl;
     }
 };

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

         if(pFriend->rp > )
         {
             m_pFriend = pFriend;
         }
     }
     void ChickenDinner()
     {
         if(m_pFriend == )
         {
             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[];    //  聚合到 家庭中
 public:
     CFamily()
     {
         for(int i=;i<;i++)
             pArr[i] = ;
     }
     ~CFamily()
     {
         for(int i=;i<;i++)
         {
             if(pArr[i] != )
             {
                 delete pArr[i];
                 pArr[i] = ;
             }
         }
     }
 public:
     void PushPerson(CPerson* ps)
     {
         if(ps == )
             return;
         for(int i=;i<;i++)
         {
             if(pArr[i] == )
             {
                 pArr[i] = ps;
                 return;
             }
         }
     }
     void AllPersonCoding(CComputer& cm)
     {
         for(int i=;i<;i++)
         {
             if(pArr[i] != )
             {
                 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 ;
 }

而从纵向关系来看的关系有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 ;
 }

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

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