程序设计3

 

有这样一种需求，两个类：

class A

{

    B b;

    //在成员函数中使用b

};

 

class B

{

//需要调用A的成员函数(算法)

};

 

这种情况下，A类是一个全局的控制类，它有一系列的算法调用各个子模块，然而子模块在自己的任务中，有时需要回调全局控制类A的算法。设计一种什么结构可以完成这种需求？

现在的方法是，把需要回调的A的算法做成一个接口，A类从这个接口继承，B类拥有这个接口的一个指针，并提供该接口指针的初始化函数。把A类的this指针初始化给b，使得B类可以通过该接口回调A类的算法。按照这种思路，下面是一个测试例子：

//接口

#ifndef __IBS_H__

#define __IBS_H__

 

class IBS

{

public:

     IBS(void);

     ~IBS(void);

     virtual void Print(int Val) = 0;

};

 

#endif //__IBS_H__

 

     //相当于B类：拥有接口的指针及初始化方法

#ifndef __SMALL_H__

#define __SMALL_H__

#include "IBS.h"

 

class CSmall

{

public:

     CSmall(void);

     ~CSmall(void);

     void Ini(IBS* pBS);

     void SmallPrint(int Val);

private:

     IBS* m_pBS;

};

 

#endif //__SMALL_H__

 

#include "StdAfx.h"

#include "./small.h"

 

CSmall::CSmall(void)

{

     m_pBS = NULL;

}

 

CSmall::~CSmall(void)

{

}

 

void CSmall::SmallPrint(int Val)

{

     if( m_pBS )

         m_pBS->Print(Val);

}

 

void CSmall::Ini(IBS* pBS)

{

     m_pBS = pBS;

}

 

     //相当于A类：对接口继承实现

#ifndef __BIG_H__

#define __BIG_H__

 

#include "IBS.h"

#include "Small.h"

 

class CBig:

     public IBS

{

public:

     CBig(void);

     ~CBig(void);

     void Print(void);    //对外方法

    void Ini(void);

private:

     CSmall m_Small;

private:

     void Print(int Val); //实现纯虚方法

     int BigPrint(int Val);

};

 

#endif //__BIG_H__

 

#include "StdAfx.h"

#include "./big.h"

 

CBig::CBig(void)

{

}

 

CBig::~CBig(void)

{

}

 

int CBig::BigPrint(int Val)

{

     std::cout<<"/nin BigPrint:/t"<<Val<<"/n";

     return 0;

}

 

void CBig::Print(int Val) //纯虚方法实现

{

     BigPrint(Val);

}

 

void CBig::Print(void)

{

     m_Small.SmallPrint(0); //调small print

}

 

void CBig::Ini(void)

{

     m_Small.Ini(this); //指向this

}