Good day!

There was a question when designing classes of controllers for representations. For example, there is the following class hierarchy:

class IController { public: virtual void add(/*...*/) = 0; virtual void edit(/*...*/) = 0; virtual ~IController() = default; }; class StandartController : public IController { public: virtual void add(/*...*/) override; virtual void edit(/*...*/) override; }

It is also necessary to provide an extended version of the controller:

 class ExtentedController : public IController { public: virtual void add(/*...*/) override; virtual void edit(/*...*/) override; virtual void find(/*...*/); virtual void sort(/*...*/); // ... и другие методы }

How now, if there is an extended child, is it uniform to use the interface? I thought to apply the solution with dynamic_cast, but it seems to me that in this case, its application will indicate that there are any problems with the architecture. The second option was to highlight the extended class in a completely new hierarchy. But does it make sense? Most likely there are better solutions. I ask for help :-)

In addition to the main question: For the production of controllers, a factory is used that returns only a pointer to an interface (IController *), regardless of what type of object the client needs. The signature of the receiving view method is as follows: void setController(IContoller* ctrl) . Representations, in fact, are also a kind of class hierarchy (One interface - many implementations).

 class IView { public: IView() = delete; IView(/*...*/); ~IView() = default; //... void setController(IContoller* ctrl); //... другие методы };

When designing, the principle of "programming at the interface level" was used, but when implementations of "not like everyone else" began to appear, problems arose with their use. After all, the whole idea is known only about the controller interface. You can, of course, make a cast to the desired type in the submission, but again, I am so embarrassed by this operation that I am still looking for another solution.

  • What's the problem? find and sort appear only in the extended controller, so they can only be used where the extended controller is expected. You should not use them where a "controller at all" is expected ... Ie I, frankly, generally do not see any problem so far. - Harry
  • one
    I see only one problem - if you write override for a function, then virtual is already superfluous. Normal compilers even swear. - KoVadim
  • @Harry, for example, if the controller's factory returns a pointer to the interface, and the signature of the receiving method looks like this: void setController(IContoller* ctrl); . In this case, inside the receiving method, you will have to use dynamic_cast. I read that you need to use dynamic_cast carefully and where it belongs. Therefore, there are doubts about its use here. What if you need to add another 2 or 3 extended controllers? In the place of use add 2, 3 dynamic_cast? - Steven
  • @Steven, you have classes with the void setController(IContoller* ctrl); method void setController(IContoller* ctrl); can actually take any controller? Or do some of them expect ExtentedController ? - yrHeTaTeJlb
  • @yrHeTaTeJlb, can accept any controller that implements the interface IContoller. - Steven

1 answer 1

I do not see anything terrible in dynamic_cast, but not to the extended class - but to a separate interface. That is, for each new extension a separate interface is made, and the extended class is inherited from several interfaces. Anyone who wants to use the extended functionality of the object - trying to connect it to the interface of interest - turned out, uses it.

 #include <vector> #include <memory> class IController { public: virtual void add(/*...*/) = 0; virtual void edit(/*...*/) = 0; virtual ~IController() = default; }; class StandartController : public IController { public: virtual void add(/*...*/) override; virtual void edit(/*...*/) override; }; class IControllerSearch { public: virtual void find(/*...*/) = 0; virtual void sort(/*...*/) = 0; virtual ~IControllerSearch() = default; }; class ExtentedController : public IController, public IControllerSearch { public: void add(/*...*/) override{}; void edit(/*...*/) override{}; void find(/*...*/) override{}; void sort(/*...*/) override{}; // ... и другие методы }; int main() { std::vector<std::shared_ptr<IController>> v; v.push_back(std::shared_ptr<IController>(new ExtentedController)); for(auto& c:v){ std::shared_ptr<IControllerSearch> cs = std::dynamic_pointer_cast<IControllerSearch>(c); if(cs){ cs->find(); } } return 0; }