在解耦类方面需要帮助 [英] Need help in decoupling classes

问题描述

目前我有两个相互紧密耦合的课程。



让我们说这些课程是MainClass和HelperClass。



mainclass.h

  class  MainClass {
  public ：
 fun1（）; 
 fun2（）; 
 fun3（）; 
 
  static  MainClass * mainClass; 
}; 
 
  //   fun1的定义 
  int  MainClass :: fun1（）
 {
  //   doSomething;  
} 

助手类文件包含mainclass文件并定义MainClass的两个函数< br $> b $ b

  #include   < span class =code-keyword><   mainclass.h  >  
  
  class  HelperClass {
 helpfun1（）; 
 helpfun2（）; 
}; 
 
 MainClass :: fun1（）
 {
 HelperClass obj; 
  //   dosomethmng  
} 
 
 MainClass： ：fun2（）
 {
 HelperClass obj; 
  //   dosomethmng  
} 
 
  //  问题区域 
  //    
 HelperClass :: helpfun1（）
 {
 MainClass :: mainClass-> fun1（）; 
} 

请建议解耦这些类。

解决方案

< blockquote>这可能是您正在寻找的，也可能不是，但这是解耦类的通用方法，适用于您提供的定义：

 < span class =code-comment> //   IMainClass.h  
  class  IMainClass {
  public ：
  virtual   int  fun1（）=  0 ; 
  virtual   int  fun2（）=  0 < /跨度>; 
  virtual   int  fun3（）=  0 < /跨度>; 
  static  IMainClass * getInstance（）; 
}; 
 
  //   MainClass.h  
  #include     IMainClass.h  
   class  MainClass： public  IMainClass {
  public ：
  virtual   int  FUN1（）; 
  virtual   int  fun2（）; 
  virtual   int  fun3（）; 
 
  static  MainClass * mainClass; 
}; 
 
  //   IMainCLass.cpp  
  #include     IMainClass.h  
   #include     MainClass.h 
  IMainClass * IMainClass :: getInstance（）{
  if （MainClass :: mainClass ==  0 ）
 MainClass :: mainClass =  new  MainClass; 
  return  MainClass :: mainClass; 
} 
 
  //   MainClass.cpp  
  #include     MainClass.h 
   #include     IHelperClass.h //仅包含接口！ 
  MainClass * MainClass :: mainClass =  0 ;  //  初始化所需的静态成员！ 
  //   fun1的定义 
  int  MainClass :: fun1（）
 {
  //   doSomething;  
} 
 .. 。
 
  //   IHelperClass.h  
  class  IHelperClass {
  public ：
  virtual   int  helperfun1（）=  0 ; 
  virtual   int  helperfun2（）=  0 < /跨度>; 
  static  IHelperClass * getHelper（）; 
}; 
 
  //   HelperClass.h  
  #include     IHelperClass.h  
   class  HelperClass： public  IHelperClass {
  virtual   int  helperfun1（）; 
  virtual   int  helperfun2（）; 
}; 
 
  //   IHelperClass.h  
  #include     IHelperClass.h  
   #include     HelperClass.h 
  IHelperClass * IHelperClass :: getHelper（）{
  return   new  HelperClass; 
} 
 
  //   HelperClass.cpp  
  #include     HelperClass.h 
   #include     IMainClass.h //仅包含接口！ 
  ... 

请注意我如何将这两个类拆分为一个接口和一个实现。从MainClass，您现在可以通过接口单独引用HelperClass的所有功能，因此您只需要包含IHelperClass.h，而不是HelperClass.h。类似地，Helperclass实现可以通过其接口IMainClass访问MainClass的所有功能，并且只需要包含IMainClass.h。



我引入了get-functions来访问实际的HelperClass和MainClass类型的对象，不需要实现类声明。

这些是否耦合？ :)：

  //  啊 
  class  A 
 {
  public ：
 < span class =code-keyword> static   void  fun（）{} 
}; 

  //   test.cpp  
  #include    啊 
  
  class  B 
 {
  public ：
  void  fun（） const  {A： ：好玩（）; } 
}; 
 
  class  test 
 {
  public ：
 test（）
 {
 B b; b.fun（）; 
} 
} g_test; 

Currently I have 2 classes that are tightly coupled with one another.

Lets say the classes are MainClass and HelperClass.

mainclass.h

class MainClass{
public:
 fun1();
 fun2();
 fun3();

 static MainClass* mainClass;
};

//definition of fun1
int MainClass::fun1()
{
//doSomething;
}

the helper class file includes mainclass file and define the two functions of MainClass

#include <mainclass.h>

class HelperClass{
helpfun1();
helpfun2();
};

MainClass::fun1()
{
 HelperClass obj;
//dosomethmng
}

MainClass::fun2()
{
 HelperClass obj;
//dosomethmng
}

//Problem area
//
HelperClass::helpfun1()
{
  MainClass::mainClass->fun1();
}

Please suggest on decoupling these classes.

解决方案

This may or may not be what you're looking for, but this is the generic way of decoupling too classes, applied to the definitions you provided:

// IMainClass.h
class IMainClass {
public:
   virtual int fun1()=0;
   virtual int fun2()=0;
   virtual int fun3()=0;
   static IMainClass* getInstance();
};

// MainClass.h
#include "IMainClass.h"
class MainClass : public IMainClass{
public:
   virtual int fun1();
   virtual int fun2();
   virtual int fun3();

   static MainClass* mainClass;
};

// IMainCLass.cpp
#include "IMainClass.h"
#include "MainClass.h"
IMainClass* IMainClass::getInstance() {
   if (MainClass::mainClass == 0)
      MainClass::mainClass = new MainClass;
   return MainClass::mainClass;
}

// MainClass.cpp
#include "MainClass.h"
#include "IHelperClass.h" // only include the interface!
MainClass* MainClass::mainClass = 0; // initialization of static member required!
//definition of fun1
int MainClass::fun1()
{
   //doSomething;
}
...

// IHelperClass.h
class IHelperClass {
public:
   virtual int helperfun1()=0;
   virtual int helperfun2()=0;
   static IHelperClass* getHelper();
};

// HelperClass.h
#include "IHelperClass.h"
class HelperClass : public IHelperClass {
   virtual int helperfun1();
   virtual int helperfun2();
};

// IHelperClass.h
#include "IHelperClass.h"
#include "HelperClass.h"
IHelperClass* IHelperClass::getHelper() {
   return new HelperClass;
}

// HelperClass.cpp
#include "HelperClass.h"
#include "IMainClass.h" // only include the interface!
...

Note how I split up both classes into an interface and an implementation. From MainClass you can now reference all the functionality of HelperClass through the interface alone, so you only need to include IHelperClass.h, not HelperClass.h. Similarly, the Helperclass implementation can access all functionality from MainClass via its interface IMainClass and only needs to include IMainClass.h.

I introduced get-functions to give access to actual objects of type HelperClass and MainClass without needing the implementation class declarations.

Are these coupled ? :) :

// A.h
class A
{
public:
  static void fun() {}
};

//test.cpp
#include "A.h"

class B
{
public:
  void fun() const { A::fun(); }
};

class test
{
public:
  test()
  {
    B b; b.fun();
  }
} g_test;

这篇关于在解耦类方面需要帮助的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！