如何在保持使用一致的同時分擔責任？

我有許多類與基類和它們的繼承形成一個類層次結構。每個班級都承擔了一些責任，但這些責任並不相關。我將不同的責任放在一起，因爲我可以很容易地使用它們（我不能很清楚地表達它，請參閱說明代碼）。但這似乎不是一個好設計。如何在保持易用性的同時拆分大型課程？感謝您的建議和意見！以下請查找說明代碼。如何在保持使用一致的同時分擔責任？

// Base class. 
class Base 
{ 
public: 
    // For responsibility A 
    virtual void A1(); 
    virtual void A2(); 
    ... 

    // For responsibility B 
    virtual void B1(); 
    virtual void B2(); 
    ... 

    // More responsibilites. 
    ... 
}; 

// Derived class 1. 
class Derived_1 : public Base 
{...}; 

// More derived classes. 
... 

// A function use it. 
void Fun() 
{ 
    Base* p = new Derived_1; 
    p->A1(); // Here A1 and B1 are binded in the class Base, thus it make sure 
    p->B1(); // their uses are consistent. If they are separated, how to ensure it? 
}

來源

2013-02-05 user1899020

我會說，如果A和B的責任是完全不同的兩個人的創造單獨的類，讓孩子實現他們想要的東西這樣一些孩子想要的只是一個或僅B或兩者並保持它容易管理和維護

// Base class. 
class Base 
{ 
public: 
    // For responsibility A 
**Goes to class A** 
    virtual void A1(); 
    virtual void A2(); 
    ... 


**//Goes to class B** 
    // For responsibility B 
    virtual void B1(); 
    virtual void B2(); 
    ... 

    // More responsibilites. 
    ... 
}; 

// Derived class 1. 
class Derived_1 : public Base **//inherits from A** 
{...}; 

class Derived_2:Public A,Public B

來源

2013-02-05 01:33:57

通過具有一類以上的責任，你打破設計的Single Responsibility Principle。

通常，良好的設計遵循SOLID原則。

分手你的課程。

定義每個責任的接口。
儘量不要使用多重繼承 - use composition instead。

我已經添加了一些示例代碼來說明這一概念：

#include <iostream> 

//Interface for A 
class ResponsibilityA 
{ 
    public: 
    virtual ~ResponsibilityA(){}; 
     virtual void A1() = 0; 
     virtual void A2() = 0; 
}; 


//Interface for B 
class ResponsibilityB 
{ 
     public: 
    virtual ~ResponsibilityB(){}; 
     virtual void B1() = 0; 
     virtual void B2() = 0; 
}; 

//Concrete classes for each interface 
class ResponsibilityAExecutor : public ResponsibilityA 
{ 
     public: 
     virtual void A1(){ std::cout<<"A1 executed\n"; }; 
     virtual void A2(){ std::cout<<"A2 executed\n"; }; 
}; 

class ResponsibilityBExecutor : public ResponsibilityB 
{ 
     public: 
     virtual void B1(){ std::cout<<"B1 executed\n"; } 
     virtual void B2(){ std::cout<<"B2 executed\n"; } 
}; 

// Now we use the interface implementations in a class that needs 
// to combine both responsibilities 
class PlanExecutor 
{ 
public: 
     PlanExecutor(ResponsibilityA& a, ResponsibilityB& b) : 
     a_(a), 
     b_(b) 
     { 

     } 
     void ExecutePlan() 
     { 
       std::cout<<"Executing first part of the plan:\n"; 
       a_.A1(); 
       b_.B1(); 
       std::cout<<"Executing second part of the plan\n"; 
       a_.A2(); 
       b_.B2(); 
     } 
private: 
     ResponsibilityA &a_; 
     ResponsibilityB &b_;  
}; 

int main() 
{ 
     ResponsibilityAExecutor a; 
     ResponsibilityBExecutor b; 
     PlanExecutor p(a,b); 
     p.ExecutePlan(); 
     return 0; 
}

最後，我還需要強調命名的重要性。

來源

2013-02-05 01:42:29 Carl

如何在保持使用一致的同時分擔責任？

回答

相關問題