Funkcja czysto wirtualna, a dziedziczenie

Cześć
Jako że kod mówi więcej, niż 1000 słów oto on:

#include <iostream>

struct C {
     virtual ~C() {}
};

struct D : C {
    virtual ~D() {}
};


struct A {
    virtual void test(C *c)  = 0;
};

struct B : A {
    //void test(C *d) {}
    void test(D *d) {  std::cout << "B::D\n";  }
};

int
main(int argc, char **argv)
{
    B a;
    a.test(new D());

    return 0;
}

W C++ przy klasach abstrakcyjnych ich implementacje w klasach pochodnych muszą być dokładnie tego samego typu?

Ehh, z jakiegoś powodu wklejony kod wygląda jak wygląda.

Kod: http://pastebin.com/rTFTpGSt

Tak

@Autor wątku - jeśli Cię to męczy, poczytaj o override: http://en.cppreference.com/w/cpp/language/override

Próbuję zaimplementować MVC
Mam klasy bazowe Model, View, Controller i konkretne CModel1, CView1, CController1, CModel2, ...

http://pastebin.com/EdC4Fncw

Problem mam taki:
W CController1 metoda SetModel powinna mieć argumenty CModel1, a w CController2 powinna CModel2, itp
Myślę nad rozwiązaniem tego i tak nasuwają mi się trzy opcje:

1. czysto wirtualne metody i użycie dynamic_cast w klasach konkretnych (rzutowanie Model -> CModel1, Model -> CModel2 itp)
2. metody wirtualne, ale trzeba je także zaimplementować dla klas bazowych, co mija się z celem według mnie
3. szablony

• rozwiązanie z C++0x wspomniane wyżej

Szablony http://pastebin.com/MSmmMsX1 wydają mi się najbardziej sensowną opcją

Problem przy szablonach jest jednak taki, że nie będzie jednej klasy bazowej tylko kilka

Niestety w realnych aplikacjach to jest bardziej skomplikowane.
To ma być na zaliczenie czy do pracy?

Bo jak na zaliczenie to od biedy wersja szablonowa jest OK.

Jak do pracy, to raczej wprowadź wzorzec "obserwator", bo relacje między wartstwami wcale nie muszą być 1-1

Ani na zaliczenie, ani do pracy. Tak dla mnie, chciałbym się dowiedzieć jak to się robi

Zamierzam to zrobić tak jak jest tu: https://upload.wikimedia.org/wikipedia/commons/9/9b/Mvc_classes_pl.svg

Klasy wysyłające sygnał to "obserwowalne" / observable, klasy odbierające sygnał to "obserwatorzy"/observer. Możesz stosować do różnych warstw o ile nie jest wymagana komunikacja dwukierunkowa.

http://www.linuxtopia.org/online_books/programming_books/c++_practical_programming/c++_practical_programming_253.html
http://neurorebel.blogspot.com/2010/06/observer-pattern-in-c-without-virtual.html
http://tomdalling.com/blog/software-design/model-view-controller-mechanisms/