Hoffe das ist jetzt richtig hier.
Habe eine "Dialog"-klasse gebaut, mit entsprechendem View und so weiter, und wollt euch mal bitten das anzuschauen, ob das gut ist. Weil funktionieren tuts, aber vielleicht ist Design nicht schön. Vor allem mit dem Callback bin ich unsicher.

//.h
class FormulaDlg
:   public pat::Singleton< FormulaDlg >
{
public:
    std::string get_formula( const ViewFactory& view_factory ) const;
    static void process( std::string input );
private:
    static std::string m_formula;
};

//.cpp
std::string FormulaDlg::m_formula = "";

void FormulaDlg::process( std::string input )
{
    m_formula = input;
}

std::string FormulaDlg::get_formula( const ViewFactory& view_factory ) const
{
    FormulaDlgView* formula_view = view_factory.create_formuladlg();
    formula_view->show( FormulaDlg::instance().process );
    delete formula_view;
    return m_formula;
}

//.h
class CLIFormulaDlgView
:   public FormulaDlgView
{
public:
    CLIFormulaDlgView()
	{}
	virtual ~CLIFormulaDlgView() {}
	virtual void show( void callback( std::string input ) ) const;
};

//.cpp
void CLIFormulaDlgView::show( void callback( std::string input ) ) const
{
    std::cout << "Enter a formula please:" << std::endl;
    std::string line;
    getline( std::cin, line );
    callback( line );
}

//Aufruf in der main()
std::string formula = FormulaDlg::instance().get_formula( CLIViewFactory::instance() );

Wäre also für jegliche Tipps dankbar.
Und eine Frage hab ich auch noch: Was ist denn nun das Model und was der Controller? Weil hab ja beides in der Klasse FormulaDlg. Sollte man das trennen?

Vielen Dank schonmal
MfG

OK, ich versuche mal den Code zu analysieren... so wie ich das sehe, ist da nichts von MVC zu sehen. Eigentlich sehe ich da nur Views. Alleine die Namen (...Dlg, ...View) sollten dich hier stutzig machen.

Ein Model im MVC-Sinne gibt es in deinem Bsp. nicht. Klar, irgendwo kommt formula vom Typ String zurück. Das sind zwar Daten, aber der Sinn und Zweck von MVC hat das nichts zu tun.

Naja, hoffe ich konnte dir helfen.

Oh man, du armer.

Oh, ich bin doch nicht unsichtbar

OK, ich versuche mal den Code zu analysieren... so wie ich das sehe, ist da nichts von MVC zu sehen. Eigentlich sehe ich da nur Views. Alleine die Namen (...Dlg, ...View) sollten dich hier stutzig machen.

Warum ist das kein MVC? Was stimmt nicht mit den Namen?
Dachte der Dlg wär das Model und das View halt die "graphische" Repräsentation...is dem nicht so?

Ein Model im MVC-Sinne gibt es in deinem Bsp. nicht. Klar, irgendwo kommt formula vom Typ String zurück. Das sind zwar Daten, aber der Sinn und Zweck von MVC hat das nichts zu tun.

Was ist denn falsch?

Naja, hoffe ich konnte dir helfen.

Naja, ein bisschen, danke. Jetzt weis ich schonmal, dass ich aufm Holzweg bin.
Hast du nen Link zu ner guten Implementation vom MVC Pattern? Oder kannst dus mir vielleicht erklären was ich falsch mach? Wär echt nett

Ich vermisse auch irgendwie das Control Element in deinen Code. Artchi hat Recht.

void Controller::run( const ViewFactory& view_factory )
{
    for(;;)
    {
        switch( CmdDlg::instance().get_cmd( view_factory ) )
        {
            case CmdDlg::calc:
            {
                std::string formula = FormulaDlg::instance().get_formula( view_factory );

                // Do something with formula

                break;
            }
            case CmdDlg::end:
            {
                std::cout << "Closing" << std::endl;
                return;
            }
        }
    }
}

Das Artchi recht hat hilft mir nicht wirklich weiter.
Wär für konkrete Tipps wirklich denkbar dankbar.

Weißt du überhaupt wo der Sinn des ganzen steckt? Der Sinn ist ganz einfach: die View (Darstellung) und das Model (Daten) sollen von einander unterschiedlich austauschbar sein. Ein beliebtes Beispiel ist ein Homepage-Designer bzw. -Editor. Du kennst sicherlich Programme wie NVU? (obwohl ein Browser auch als Beispiel herhalten kann) Das Model ist ein String-Typ. Die Daten darin sind erstmal unwichtig. Vorzugsweise ist es gültiger HTML-Code. So, und die View (das ist der Clou am ModelView-Pattern!) ist beliebig austauschbar. NVU hat mind. 2 View: einen ASCII-View und einen HTML-Renderer. Als dritte View gibts noch so einen HTML-Tag-View. Aber wichtig bei der Sache ist: alle drei Views greifen auf das EINE Model zu!!! Das Model ist immer ein und der selbe String, aber die Views können beliebig ausgetauscht werden, weil die Views auf das Model zugreifen.

Das Konzept ist auf alle anderen Anwendungsbereiche übertragbar: Musik-Software. Die Sounddaten (Hz-Samples) liegen Binär vor. Jetzt kann man dazu eine Textview programmieren (der User kann die Samples als Hz-Zahlen anschauen) und eine grafische View (Hz-Kurve).

Der Controller kann manchmal weggelassen werden, weil er z.B. schon in der View mit drin ist. Das wird z.B. im Java Swing so gehandhabt. Du kannst den Controller auch extra designen.

Wichtig ist, das du dir Interfaces für das Model baust, so das die Views einheitlich auf das Interface zugreifen können. Wie du das machst, ist dir überlassen, da das MVC nur ein Pattern ist.

Hier noch ein Bild, um die Beziehungen zu zeigen:
http://java.sun.com/blueprints/patterns/images/mvc-structure-generic.gif

Schau mal hier:
http://csis.pace.edu/~bergin/mvc/gauge.jpg
Vier Views! Eine Temperatur! Die Temperatur kann sowohl als Fahrenheit, in Celsius, als Slider und als Termometer dargestellt werden. Aber alle 4 Views greifen auf eine Model-Instanz zu. Und wenn man als Benutzer an einer View was ändert (z.B. den Slider bewegt), ändern sich alle anderen 3 Views mit, weil der Controller alle Views über Änderungen informiert.

Achja, dein FormulaDlg hat mit MVC nichts zu tun. Das Ding ist einfach nur ein notwendiges Übel. CLIFormulaDlgView ist dann schon eher ein View des MVC. Aber eigentlich ist ja das Eingabefeld und Ausgabefeld der Formel die View. Und die Formel, ist das Model.