Design: classes with same implementation but different method names

I have multiple classes that have similar implementation for different named methods:

class MyClassX
{
   public int MyClassXIntMethod(){}
   public string MyClassXStringMethod(){}
}

class MyClassY
{
   public int MyClassYIntMethod(){}
   public string MyClassYStringMethod(){}
}

the methods inside the classes have similar implementation but because the method's names are different (due to 3rd party constraints) i cannot use inheritance.

I'm looking for an elegant solution tha开发者_Python百科t would be better than implementing the same functionality over and over again.

---

The classic answer IMHO is use the adpater pattern for every 3rd party calling party. Don't apply blindly but see if it is a good fit first.

class MyClassXAdapter
{
   IMyInterface _myImpClass

   public int MyClassXIntMethod(){ return _myImpClass.IntMethod()}
   public string MyClassXStringMethod(){ return _myImpClass.StringMethod() }
}

class MyClassYAdapter
{
   IMyInterface _myImpClass

   public int MyClassYIntMethod(){ return _myImpClass.IntMethod()}
   public string MyClassYStringMethod(){ _myImpClass.StringMethod() }
}

class MyClassImplementation :IMyInterface
{
   public int IntMethod(){}
   public string StringMethod(){}
}

---

And whats the problem in using composition?

class MyClassY
{
   private MyClassX myclx; 
   public int MyClassYIntMethod()
   {
     return myclx.MyClassXIntMethod();
   }
   public string MyClassYStringMethod(){...Similarly here...}
}

---

Why not simply create a common super class, and let each "MyClass_" call that common function? You can have a different program signature and still reuse the same codes pieces. Without copy and paste the same code again.

class MyClassX extends MyClassGeneric
{
   public int MyClassXIntMethod(){}
   public string MyClassXStringMethod(){}
}

class MyClassY extends MyClassGeneric
{
   public int MyClassYIntMethod(){ return MyClassIntMethod();}
   public string MyClassYStringMethod(){return MyClassStringMethod();}
}

class MyClassGeneric
{
   protected int MyClassIntMethod(){ /*...... logic .....*/ return 0; }
   protected string MyClassStringMethod(){/*...... logic ....*/return "";}
}

---

Real world example.

Without "software patternitis". (I apply software patterns, very useful, but, I'm not adicted to them).

---

collections.hpp

#define pointer void*

class Collection {
protected:
  VIRTUAL bool isEmpty();

  VIRTUAL void Clear();
}

class ArrayBasedCollection: public Collection {
protected:
  int internalInsertFirst(pointer Item);
  int internalInsertLast(pointer Item);

  pointer internalExtractFirst(int Index);
  pointer internalExtractLast(int Index);
}

class Stack: public ArrayBasedCollection {
public:
  OVERLOADED bool isEmpty();
  OVERLOADED void Clear();

  // calls protected "internalInsertFirt"
  void Push(pointer Item);
  // calls protected "internalExtractLast"
  pointer Pop(pointer Item);
}

class Queue: public ArrayBasedCollection {
public:
  OVERLOADED bool isEmpty();
  OVERLOADED void Clear();

  // calls protected "internalInsertFirt"
  void Push(pointer Item);
  // calls protected "internalExtractFirst"
  pointer Pop(pointer Item);
}

---

Cheers.