0

I am creating a class which has an instance variable that has many different implementations, but the problem is that all of the implementations have a slightly different interface.

Example:

class GameObject {
    virtual Transform * getTransform() = 0;
};

class Transform {
    virtual void setPosition() = 0;
    virtual Model getModel() = 0;
    virtual void refreshModel() = 0;
    virtual void Draw() = 0;
};

// This Class has a .cpp
class TransformImpl : public Transform {
    virtual void setPosition();
    Model getModel();
    void refreshModel();
    void Draw();
};

// This Class has a .cpp
class InstancedTransformImpl : public Transform {
    void setPosition(int instance);
    std::vector<Model> getModels(); // notice the difference in the interface
    void refreshModel();
    void Draw();
};

The point I want to make is that I only want one GameObject class thus I want my geTransform() method have a return type of class Transform. The problem I'm having is that since TransformImpl and InstancedTrasformImpl have slightly different interfaces I can't have getTransform() to return a Transform and instead I need to implement GameObject twice with lots of duplicated code.

Is there a good solution to implement GameObject once?

Or would it be better to have multiple GameObject implementations each having there respective TransformImpl's with a more lenient interface?

Improve this question
6
  • 5
    Could you standardize on std::vector<Model> getModels() for both interfaces? Model getModel() coiuld be represented as a vector with one element. Commented Jul 25, 2017 at 0:52
  • this is just a simple example, there are more methods. Basically one class contains many instances of transform and the other class contains only one instance. I'll update Commented Jul 25, 2017 at 3:32
  • can you make Model and std::vector<Model> a template parameter in interface/implementatoin ? Commented Jul 25, 2017 at 10:44
  • @k3b I thought the same, but what to do with setPosition()? Commented Jul 26, 2017 at 6:35
  • setPosition is modell specific so you have to implement two model-specific classes. the interface can still be generic. Commented Jul 26, 2017 at 9:47

2 Answers 2

Reset to default
3

If you want to use two (or more) implementation classes interchangeably, then those implementation classes must implement the same interface. This is especially important if the selection which implementation class you interact with is decided at runtime.

If the difference between the interfaces is that one class allows you access to N instances of something and the other to just 1, then the common interface should give you access to N instances.
Allowing access to a more restricted number can be modeled as a special case of the situation with access to an unrestricted number.

In this case, the interface should be

class Transform {
    virtual void setPosition(int instance) = 0;
    virtual std::vector<Model> getModel() = 0;
    virtual void refreshModel() = 0;
    virtual void Draw() = 0;
};

The TransformImpl class can then always return a vector with 1 element from getModel and either ignore the instance parameter to setPosition or report an error if that parameter has a value other than 0 or 1 (depending on where you start counting).

Improve this answer
3
  • Isn't this bad practice though? It doesn't seem right to be sending over a parameter which isn't really used and for it to be returning a vector of only size one Commented Jul 25, 2017 at 21:43
  • 1
    @archimede, it is only a bad practice if there is no good reason for it. In your case, the alternative is a massive duplication of code, which is a much bigger bad practice. Commented Jul 26, 2017 at 6:41
  • 1
    You could apply Segration of Interface principle too. But It would make the code a little bit more complex. So far, Bart's answer is a fairly good solution. It will allow you to treat all Transform implementations in the very same way. Anyways, I got the feeling that Transform interface is failing as abstraction. I think the design misses a cross-cutting concept that has led you to segment the implementations in such a way that some of them will accomplish with the interface and others will do just 50%. Commented Jul 26, 2017 at 7:27
2

How about the adapter pattern?
Create multiple types of GameObject Implementations and work with all of them through an adapter that abstracts their differences: https://sourcemaking.com/design_patterns/adapter

Improve this answer
3
  • What if I have an InstancedTransfom interface. Both my InstancedTransformImpl and TransformImpl implement InstancedTransform but what if I make a TransformImpl adapter which always grabs the 0th element. But if I do this how can I hide the InstancedTransform methods from the client using TransformImpl. To avoid this would I need to have an instance of InstancedTransform Commented Jul 26, 2017 at 0:17
  • But if I have an instance of InstancedTransform in TransformImpl then it'll screw up GameObject's interface for getTransform() Commented Jul 26, 2017 at 0:52
  • The adapter pattern reveals only what you want it to reveal. You can even create a factory that produces adapters, each one relating to the right object and wrapping it in an appropriate way. Commented Jul 26, 2017 at 6:12

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.