Расширенная версия интерфейса для потомка класса

class IController 
{
public:
    virtual void add(/*...*/) = 0;
    virtual void edit(/*...*/) = 0;
    // ... и другие методы
    virtual ~IController() = default; 
};
 
class StandartController : public IController
{
public:
    void add(/*...*/) override;
    void edit(/*...*/) override;
};

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

void setController(IContoller* ctrl);

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

auto* const controller = factory::build(EXTENDED);
 
extView.setController(controller);
 
...
 
 
IExtentedView::setController(IContoller* ctrl)
{
    #ifdef NDEBUG
        this->m_controller = static_cast<ExtentedController*>(ctrl);
    #else
        // для дебага на всякий случай проверим,
        // что расширенной вьюхе прислали расширенный контроллер
        this->m_controller = dynamic_cast<ExtentedController*>(ctrl);
    #endif
    assert(this->m_controller);
 
    // теперь расширенная вьюха 
    // может спокойно пользоваться 
    // расширенным функционалом 
    // расширенного интерфейса
 
    // без всяких кастов.
}

class visitor;
 
class bird
{
public:
    void accept(visitor & v) = 0;
};
 
class eagle: public bird
{
public:
    void accept(visitor & v) { v.visit(*this); } 
 
    void fly() { }
    void eat() { }
};
 
class penguin: public bird
{
public:
    void accept(visitor & v) { v.visit(*this); }
 
    void eat() { }
};
 
// -------------
class visitor
{
public:
    virtual void visit(eagle & e) = 0;
    virtual void visit(penguin & p) = 0;
};
 
class eat: public visitor
{
public:
    void visit(eagle & e) { e.eat(); }
    void visit(penguin & p) { p.eat(); }
};
 
class fly: public visitor
{
public:
    void visit(eagle & e) { e.fly(); }
    void visit(pengiun & p) { throw "penguins cannot fly!"; }
};

class IVisitor;
 
class IController
{
public:
    IController() = default;
    virtual ~IController() = default;
    virtual void add() { std::cout << "Standart behavior\n";  }
    virtual void edit() { std::cout << "Standart behavior\n"; }
    virtual void accept(IVisitor* ) = 0;
};
 
class StandartController : public IController
{
public:
    void accept(IVisitor* ) override;
};
 
class ExtentedContoller : public IController
{
public:
    void find() { std::cout << "ExtentedContoller: void find()\n"; }
 
    void accept(IVisitor* ) override;
};

class ControllerFactory
{
public:
    template<typename T, typename std :: enable_if<std :: base_of<ExtentedController, T> :: value, T> :: type* = nullptr>
    void getController()
    {
        ... // Поиск контроллера в векторе _extentedControllers
        return controller;
    }
    template<typename T, typename std :: enable_if<std :: base_of<SuperController, T> :: value, T> :: type* = nullptr>
    void getController()
    {
        ... // Поиск контроллера в векторе _superControllers
        return controller;
    }
...
private:
    std :: vector<SuperController*> _superControllers;
    std :: vector<ExtentedController*> _extentedController;
...
};

...
template<typename T, typename... Arg, typename std :: enable_if<std :: base_of<ExtentedController, T> :: value, T> :: type* = nullptr>
T* addController( Args... arg )
{
    ...
    T* controller = new T( std :: forward<Args>( arg )... );
    ...
    _extentedController.push_back( controller );
 
}
...