三個類之間的相互調用實現

                                             三個類之間的相互調用

        由來：在項目開發的時候，定義了三個核心類（ClassA，ClassB, ClassC），三個類之間存在調用關系如下：ClassC是管理類，需要調用ClassA, ClassB的接口；同時作為被管理類，ClassA, ClassB需要又需要調用ClassC的接口。

        理清楚三類之間的關系：

       1）定義順序：ClassA, ClassB先於ClassC。

       2）調用關系：ClassC要調用ClassA的接口、ClassB的接口；ClassA要調用ClassC的接口，classB要調用ClassC的接口。

       其實，理清楚1），2）後我們發現，ClassA與ClassB之間並無直接調用關系（如果可以復雜點的話，可以再加處理）。

       核心點：兩個類需要相互調用對端類的接口時，需要主要包含對方頭文件及前向聲明的問題，這個網上都有不少網友解答。舉例上面ClassA與ClassC的關系如下：

        第一步:定義ClassA.h , classA.cpp , ClassC.h ClassC.cpp；

        第二步：在ClassC.h頭文件加上 #include “ClassA.h”, 在ClassC的cpp文件中加上#include “ClassC.h”；

        第三步：在ClassA.h頭文件中加上 #include “ClassA.h”, 在ClassA的cpp文件中加上 #include “ClassA.h” , #include “ClassC.h”。

        上面的不清楚的話，詳見實踐代碼：

         代碼實現：

 
/*
**ClassA.h
*/
#ifndefCLASSA_H_H
#defineCLASSA_H_H
 
classClassC;
 
classClassA
{
public:
       ClassA(ClassC* pC);
       ClassA();
       ~ClassA();
 
public:
       void displayA();
       void invoke_classC_in_ClassA();
 
public:
       ClassC* m_pC;
};
 
#endif
 
/*
**ClassA.cpp
*/
#include"stdafx.h"
#include"ClassA.h"
#include"classC.h"
#include<iostream>
usingnamespace std;
 
ClassA::ClassA(ClassC*pC)
{
       cout << "ClassA(ClassC* pC)constructor is running!" << endl;
       m_pC = pC;
}
 
ClassA::ClassA()
{
       cout << "ClassA() constructoris running!" << endl;
      
}
ClassA::~ClassA()
{
       cout << "ClassA destructor isrunning!" << endl;
}
 
 
voidClassA::invoke_classC_in_ClassA()
{
       cout <<"ClassA::invoke_classC_in_ClassA() is running" << endl;
       m_pC->displayC();
}
 
voidClassA::displayA()
{
       cout << "classA::displayA() isrunning!" << endl;
}
 
/*
**ClassB.h
*/
#ifndefCLASSB_H_H
#defineCLASSB_H_H
 
classClassC;
 
classClassB
{
public:
       ClassB(ClassC* pC);
       ClassB();
       ~ClassB();
 
public:
       void displayB();
       void invoke_classC_in_ClassB();
 
public:
       ClassC* m_pC;
 
};
 
#endif
 
/*
**ClassB.cpp
*/
 
#include"stdafx.h"
#include"ClassB.h"
#include"classC.h"
#include<iostream>
usingnamespace std;
 
ClassB::ClassB(ClassC*pC)
{
       cout << "ClassB(ClassC* pC)constructor is running!" << endl;
       m_pC = pC;
}
 
ClassB::ClassB()
{
       cout << "ClassB() constructoris running!" << endl;
      
}
ClassB::~ClassB()
{
       cout << "ClassB destructor isrunning!" << endl;
}
 
 
voidClassB::displayB()
{
       cout << "ClassB::displayB() isrunning!" << endl;
}
 
voidClassB::invoke_classC_in_ClassB()
{
       cout <<"ClassB::invoke_classC_in_ClassB() is running!" << endl;
 
       m_pC->displayC();
}
 
/*
**ClassC.h
*/
#ifndefCLASSC_H_H
#defineCLASSC_H_H
 
#include"ClassA.h"
#include"ClassB.h"
 
 
classClassC
{
public:
       ClassC();
       ~ClassC();
 
public:
       void displayC();
       void invoke_ClassA_in_ClassC();
       void invoke_ClassB_in_ClassC();
 
public:
       ClassA* m_pA;
       ClassB* m_pB;
};
 
#endif
 
/*
**ClassC.cpp
*/
#include"stdafx.h"
#include"ClassC.h"
#include<iostream>
usingnamespace std;
 
ClassC::ClassC()
{
       cout << "ClassC() constructoris running!" << endl;
 
       m_pA = new ClassA();
       m_pB = new ClassB();
      
}
ClassC::~ClassC()
{
       cout << "ClassC destructor isrunning!" << endl;
       if(NULL != m_pA)
       {
              delete m_pA;
              m_pA = NULL;
       }
       if(NULL != m_pB)
       {
              delete m_pB;
              m_pB = NULL;
       }
}
 
 
voidClassC::displayC()
{
       cout << "ClassC::displayC() isrunning!" << endl;
}
 
voidClassC::invoke_ClassA_in_ClassC()
{
       cout <<"ClassC::invoke_ClassA_in_ClassC() is running!" << endl;
       m_pA->displayA();
}
 
voidClassC::invoke_ClassB_in_ClassC()
{
       cout <<"ClassC::invoke_ClassB_in_ClassC() is running!" << endl;
       m_pB->displayB();
}
 
/*
**main.cpp
*/
#include"stdafx.h"
#include"ClassA.h"
#include"ClassB.h"
#include"ClassC.h"
#include<iostream>
using namespacestd;
 
intmain(int argc, char* argv[])
{
       ClassC* pC = new ClassC;
 
       cout << "C類調用A類:" << endl;
       pC->invoke_ClassA_in_ClassC();
 
       cout << endl << "C類調用B類:" << endl;
       pC->invoke_ClassB_in_ClassC();
 
 
       cout << endl << "A類調用C類:" << endl;
       ClassA* pA = new ClassA(pC);
       pA->invoke_classC_in_ClassA();
 
       cout << endl << "B類調用C類:" << endl;
       ClassB* pB = new ClassB(pC);
       pB->invoke_classC_in_ClassB();
 
       cout << endl;
    delete pB;
       delete pA;
       delete pC;
 
       return 0;
}