//classes.h
class Application
{
  static int nInstance;
  public:
    Application();
    void Initialize();
    virtual void Main() {};
    int hInstance();
    ~Application();
};

int Application::nInstance = 0;

Application::Application()
{ Initialize(); }

void Application::Initialize()
{ nInstance++; Main(); }

int Application::hInstance()
{ return nInstance; }

Application::~Application()
{ nInstance--; }

int main() { return 0; }

Und hier ein beliebiges Programm:

// HelloWorld.cpp

#include <iostream>
#include "classes"

using namespace std;

class HelloWorld: public Application
{
  public:
    void Main()
    {
      cout << "Hello, world." << endl;
    }
} HelloWorld;

Jetzt wird aber nicht, wie von mir erwartet, die Main()-Methode der Klasse "HelloWorld" aufgerufen, sondern anscheinend die der Klasse "Application", die ja nichts macht.
Was läuft gedanklich schief? Wer kann mir bitte helfen?
P.S.:
Die einzige Möglichkeit, wie es läuft, die ich aber nicht will, wäre:

// classes.h
class Application
{
  static int nInstance;
  public:
    Application();
    int hInstance();
    ~Application();
};

int Application::nInstance = 0;

Application::Application()
{ nInstance++; }

int Application::hInstance()
{ return nInstance; }

Application::~Application()
{ nInstance--; }

int main() { return 0; }

// HelloWorld.cpp

#include <iostream>
#include "classes"

using namespace std;

class HelloWorld: public Application
{
  public: HelloWorld()
  {
    cout << "Hello, world." << endl;
  }
} HelloWorld;

Was läuft gedanklich schief?

Du rufst Main aus dem Konstruktor der Basisklasse auf (die zwischengeschaltete Initialize-Methode ändert daran nichts). Zu diesem Zeitpunkt ist aber dein Objekt noch kein HelloWorld-Objekt, der HelloWorld-Konstruktor wurde noch gar nicht ausgeführt. Daher wird Application::Main aufgerufen.

Es gibt in C++ auch keine mir bekannte Möglichkeit (die kein gefährlicher Hack wäre) genau das hinzubekommen was du willst.
Du könntest es allerdings so machen wie die MFC es auch macht. Schematisch sieht das so aus:

// Application.h:
class Application
{
public:
    Application();

    virtual int Run() = 0;

    virtual bool Initialize();
    virtual void Cleanup();

    static int Main();

private:
    static Application* sm_theApplication;
};

// Application.cpp:
#include "Application.h"

Application* Application::sm_theApplication = 0;

Application::Application()
{
    assert(sm_theApplication == 0);
    sm_theApplication = this;
}

int Application::Main()
{
    assert(sm_theApplication != 0);
    if (!sm_theApplication->Initialize())
        return 1;

    int rc = sm_theApplication->Main();
    sm_theApplication->Cleanup();
    return rc;
}

bool Application::Initialize()
{
    return true;
}

void Application::Cleanup()
{
}

// Main.cpp
#include "Application.h"

int main()
{
    return Application::Main();
}

// FooApp.cpp
#include "Application.h"
#include <conio.h>

namespace {

class FooApp : public Application
{
    int Run()
    {
        printf("Blubb.\n");
    }
};

FooApp xyz; // name ist egal

} // namespace

Hallo erstmal.
Ich will durch Auslagern die main()-Funktion auslassen, und dann eine Main()-Methode in einer selbstdefinierten Klasse als Aufrufpunkt verwenden. Ähnlich wie in C#.

Du übersiehst dabei eine entscheidende Kleinigkeit In C# ist die Main static, womit sie im eigendlichen Sinne keine Methode der Klasse selbst ist, sondern nur eine Methode die innerhalb des Klassen-Codes definiert wird.

Genaugenommen bildet C# den main-Aufruf von C/C++ nach, nur halt im Rahmen der Möglichkeiten der Sprache. Will sagen, da in C# keine Methoden "ausserhalb" einer Klassendefinition definiert werden können, muß es halt, ebenso wie in java innerhalb eine Klasse definiert werden. (In Java ist die Main auch static btw...)

Ansonsten gilt fuer die C# main das gleiche wie fuer C/C++

http://msdn2.microsoft.com/en-us/library/acy3edy3(vs.71).aspx

Hab's jetzt durch einen kleinen "Trick" anders gemacht.
In der Headerdatei "classes.h" in der die Klasse Application steht,
sind nur Konstruktor, Destruktor, static nInstance und hInstance() definiert.

Das main() wird durch einen billigen Trick aufgerufen:

Da ich noch ein älteres C++ habe, das kein namespace kennt, habe ich namespace mit folgendem per #define definiert:

...
#define namespace(x) int main(){x xMain; xMain.Main(); return 0;}
...

Im einem Program sähe das ganze so aus:

#include <iostream.h>
#include "classes.h"

namespace
(
  class Hallo: public Application
  {
    public:
      static void Main()
      {
        cout << "Irgendwas.";
      }
  }
)

Die runden Klammern nach namespace sind absicht, da ja die Klasse im
Rumpf per "classes.h" ein Makro-Parameter ist. Und das "vergessene"
Semikolon ist auch absicht, da dies durch den Inhalt des Makros
(... x xMain; ...) automatisch eingefügt wird.

Kleiner Nachteil: Ich kann nur 1 namespace, der auch noch namenlos ist,
definieren, da ja dort die main()-Funktion steht.

Naja. Zum Glück hab' ich ja auch noch Visual-C#. Ich wollte ja nur bissel was dazulernen.
Danke nochmal.

Da ich noch ein älteres C++ habe, das kein namespace kennt, habe ich namespace mit folgendem per #define definiert:

...
#define namespace(x) int main(){x xMain; xMain.Main(); return 0;}
...

Im einem Program sähe das ganze so aus:

#include <iostream.h>
#include "classes.h"

namespace
(
  class Hallo: public Application
  {
    public:
      static void Main()
      {
        cout << "Irgendwas.";
      }
  }
)

Gratuliere, du bist ein Vollpfosten.

Das ist fast auf einem Level mit den Leuten die true auf 0 und false auf 1 umdefinieren. (Lacht nicht hab ich alles schon selber gesehen... in Produktivsoftware...)

Da ich noch ein älteres C++ habe

kannste mir dein c++ verkaufen?

#pragma comment(linker, "/ENTRY:?Start@Application@@SAHHQAPA_W@Z")

class Application
{
public:
	static int Start(int argc, wchar_t* argv[]);
};

int Application::Start(int argc, wchar_t* argv[])
{
	return 0;
}

Ist zwar so wie es da steht wenig portabel, aber wo ein Wille da auch ein Weg

Hab den Code mit #pragma probiert, ich kann mir zwar denken was der
pragma-Befehl an dieser Stelle macht, aber nachvollziehen kann ich's nicht.
Hab ihn unter Linux ausprobiert und es funktioniert nicht, er will immer noch ein Main() haben.

Einsichtig: Das mit dem "umdefinieren" des namespaces ist nicht wirklich gut,
hab auch gestern 'ne neue Methode probiert.

Gibt es zufällig die Möglichkeit, einen Zeiger auf eine beliebige Funktion zu definieren und diesen dann als Funktion zu nutzen, also so nach dem Motto...

Typ Funktion()
{
  ...
}
...
Typ Zeiger = Funktion();
// oder: Typ Zeiger = *Funktion() ?
// oder: Typ Zeiger = &Funktion() ?
// oder, oder, oder, ...
...
Zeiger(); //hier wird eigentlich Funktion() aufgerufen

Mit Zeigern hab ich's nämlich meist nicht so, bin bisher meistens ohne
ausgekommen, wenn's aber sein muss, oder besser ist, nehm' ich natürlich
welche.

#include <iostream>

void foo()
{
	std::cout << "calling foo()" << std::endl;
}

typedef void ( *fun_ptr )();

int main()
{
	fun_ptr ptr = foo;
	ptr();
}

"Classes.h"

#ifndef __CLASSES_H
#define __CLASSES_H

namespace Classes
{
  typedef void TForm;

  class Application
  {
    static int nInstance;
    typedef void (*TForm)();
    public:
      Application();
      Application(TForm Pointer);
      TForm Run;
      int hInstance();
      ~Application();
  };
}

int Classes::Application::nInstance = -1;
Classes::Application::Application() { ++nInstance; }
Classes::Application::Application(TForm Pointer) { ++nInstance; Run = Pointer; }
int Classes::Application::hInstance() { return nInstance; }
Classes::Application::~Application() { Run(); --nInstance; }

int main() { return 0; }

#endif

"Form1.h":

#include <iostream>

using namespace std;

namespace Form1
{
  class TForm1
  {
    public: static void Main()
    {
      cout << "Geht." << endl;
    }
  };
}

"Form1.cpp"

#include <iostream>

#include "Classes.h"
#include "Form1.h"

namespace Form1
{
  Classes::Application Form1(TForm1::Main);
}

Man schreibt also sozusagen eine Headerdatei mit den eigentlichen Klassen (ähnlich wie in C#) und man benötigt man eine cpp-Datei (wie Form1.cpp), in der 1. "Classes.h" und die eigenen Klassen mit geincludet werden, und 2. mittels Classes::Application name(klasse::funktion) defineirt wird, wo das Hauptprogramm steht (also der main()-Ersatz).
Der Konstruktor definiert quasi einen Zeiger (Klasse Application, Element Run) auf das Hauptprogramm (Beispiel siehe oben).

Jedenfalls MANY THNX für eure Hilfe. Wer interessiert ist, kann den Code auch für sich verwednen.

Aber bestimmte Dinge anders zu machen als andere ist doch auch in Ordnung.
Alle die in C++ programmieren, schreiben ordentlich, brav ihr main() und ich wollt des halt ned. Gut, wenn ich etz blos a kleines Testprogramm hab, das mal blos "Hallo Welt" schreibt, dann mach ich sowas ned. Da schreib ich dann schon main()... aber für größeres könnte ich mir meine Variante scho vorstellen, vor allem weil ich C# bloß für WinXP hab und unter Linux "nur" C++.
Aber egal.

Kurz: Es sollte mir eigentlich nur lernmäßig dienen.

CU@ALL

Außerdem zwingt dich niemand alles in die Main zu stopfen. In einem C++ Programm kann die main() durchaus so aussehen:

int main()
{
  Application app;

  return app.main(); //oder beliebiger anderer Name
}

In einer realen Anwendung wäre wahrscheinlich noch ein try..catch außen herum und man würde die Kommandozeile auswerten.

P.S. Das was du hier tust ist ein typischer Fall für www.thedailywtf.com weil du ein Problem löst das nicht existiert.

Ich hab ja auch C#. Ich wollte das ja nur, um etwas dazu zu lernen.
Und hierbei brauchte ich halt etwas Hilfe. So an sich ist doch C++ OK.

Aber bestimmte Dinge anders zu machen als andere ist doch auch in Ordnung.
Alle die in C++ programmieren, schreiben ordentlich, brav ihr main() und ich wollt des halt ned. Gut, wenn ich etz blos a kleines Testprogramm hab, das mal blos "Hallo Welt" schreibt, dann mach ich sowas ned. Da schreib ich dann schon main()... aber für größeres könnte ich mir meine Variante scho vorstellen, vor allem weil ich C# bloß für WinXP hab und unter Linux "nur" C++.
Aber egal..

]

Früher oder später wirst Du noch lernen das es gute Gründe gibt warum gute Programmierer sich an Standarts, Design Patterns und Best Praktices halten. Mit der Einstellung die Du da zeigst wohl eher später und "the hard way".

Naja, solange Du es nciht als Job machen willst sondern nur als Hobby ists ziemlich egal

Oder um es mit einem Zitat aus eine Film zu sagen: "Wenn Du einen Nagel in die wand schlagen willst, dann nimm einen Hammer und schlag den Nagel in die Wand". Was Du machst ist eher der Versuch mit einer Hydraulikpresse den Nagel in die Wand zu drücken...

[quote="Robert K."]
Kurz: Es sollte mir eigentlich nur lernmäßig dienen.[/quote

Und das Lernergebnis hätte sein sollen das der beste udn sinnvollste Weg in C++ immer noch ein simples

class Application {

};

int main()
{
    Application.Run()
}

wäre.

Ps: Bin selber ein begeisterter C# Progger... Das mal am Rande...