Класс шаблона С++, ссылающийся на самого себя

Это возможная реализация

template<typename View, typename Model>
struct Controller {
    View *view;
    Model *model;

    Controller() : view(0), model(0) {}
    void setUp(View *v, Model *m) {
        view = v;
        model = m;
    }

    virtual void change() = 0;
};

template<typename Controller, typename Model>
struct View {
    Controller *controller;
    Model *model;

    View() : controller(0), model(0) {}
    void setUp(Controller *c, Model *m) {
        controller = &c;
        model = &m;
    }

    virtual void display() = 0;
};

Чтобы создать экземпляр, хитрость заключается в том, чтобы получить класс из шаблона, который имеет предварительно объявленный класс в качестве параметра:

struct MyModel {
    int x;
    MyModel(int x) : x(x) {}
};

struct MyController;
struct MyView : View<MyController, MyModel>
{
    void display() { std::cout << model->x << std::endl; }
};

struct MyController : Controller<MyView, MyModel>
{
    void change() { model->x = 44; }
};

После этого вы можете создавать экземпляры и настраивать их

int main(int argc, const char *argv[]) {
    MyModel m(42);
    MyView v;
    MyController c;
    v.setUp(&c, &m); c.setUp(&v, &m);

    v.display();
    c.change();
    v.display();

    return 0;
}

Это компилируется:

class MyView;
class MyController: public Controller<Model,MyView>{};
class MyView: public View<Model,MyController>{};
MyController myC;
MyView myV;

Но это зависит от того, как написаны Controller и/или View. MyView является неполным на момент создания MyController, поэтому можно использовать только указатели.

Ты не сможешь это сделать. Несколько мыслей, которые помогут вам двигаться дальше:

• Используйте шаблоны только для определенных функций-членов

  Если вам в классах не нужно хранить элементы данных, вы можете написать:

  template<class Model>
  class Controller {
  public:
      void foo() // does not need View
      { ... }
  
      template<typename View>
      void bar(const View& v) // works with a specific View
      { ... }
  };    
  

• Возможно, Controller не нужно знать View?

  template<class Model> // no dependency on View
  class Controller { /* Implement Controller */ };   
  template<class Model, class Controller>
  class View { /* Implement View */ };
  // no it works
  Controller<MyModel> ctrl;
  View<MyModel, Controller<MyModel>> view;
  

• Используйте интерфейс:

  class IController { ... };
  class IView { ... };
  template<class Model>
  class Controller : public IController { /* Implement Controller */ };   
  template<class Model>
  class View : public IView { /* Implement View */ };
  

• Получайте типы из ваших типов шаблонов:

  class MyView;
  class MyController : public Controller<MyModel,MyView> { };
  class MyView : public View<MyModel,MyController> { };
  

  Здесь вы должны помнить об этой проблеме: Два шаблона классы, состоящие из членов друг друга