Discussion :

[YéTeeh]

Bonjour (et joyeux noël),

J'aimerais faire rentrer la fonction main() dans une classe, afin de n'avoir vraiment aucune fonction classique. Alors je me suis dit :

Ha Ha ! Je vais faire une fonction statique, comme ça elle n'aura pas de paramètre "this" et je conquerrai le monde!

Alors hop, j'ai écrit ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
class A
{
public:
  static int main( int argc, char* argv[] )
  {
    return 0;
  }
};

Et là, snif, ça ne marche pas. Je suppose que la fonction n'est pas une fonction main() valide parce qu'elle est liée à A, et je suis déçu.

Auriez-vous des idées pour m'aider à aboutir ?

[Clad3]

En dehors du fait que je ne sais pas comment contourner le problème, j'aimerai savoir ce que tu cherches à faire en faisant ca ? ( car je suis sur qu'il doit y avoir une autre facons, tout aussi élégante de procéder )

[JolyLoic]

En C++, main est forcément une fonction libre. C'est aussi une fonction spéciale que tu n'as pas le droit d'appeler toi même. En quoi est-ce gênant ?

Les fonctions classiques sont une bonne chose, et tu en auras forcément dans tout programme assez grand que tu écriras. Vouloir par exemple faire d'un opérateur + une fonction membre est souvent une mauvaise idée, ou faire un opérateur << membre souvent impossible.

Ce n'est pas parce qu'une fonction sera membre ou pas que du code sera objet ou pas (il y a du code orienté objet en C, tout comme du code non orienté objet en Java), et ce n'est pas non plus parce qu'il sera objet ou pas qu'il sera bon ou pas.

Et puis d'ailleurs, une fonction de classe statique n'est rien d'autre qu'une fonction non membre dans un namespace...

[YéTeeh]

j'aimerai savoir ce que tu cherches à faire en faisant ca ?

Et bien à vrai dire, je développe une petite bibliothèqe sympa (libclaw) (je met le lien, mais pour l'instant il n'y a pas d'archive à télécharger, tout est sur CVS). J'aimerais y mettre une classe application qui permet de gérer facilement l'application et les arguments de la ligne de commande. L'objectif est de pouvoir l'utiliser un peu comme cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
/* Ca c'est l'application développée */
class my_app : public claw::application
{
public:
  my_app( int& argc, char** &argv );
  void run();
}; // class my_app
 
/* Et ça c'est pour que la fonction main() exécute my_app.
 j'aurais aussi pu faire hériter my_app de claw::application::implement<my_app> pour avoir le même résultat. */
class imp : public claw::application::implement<my_app> {};

Où la classe claw::application::implement est définie ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
template< class App >
    class implement
    {
    public:
      static int main( int argc, char* argv[] );
    }; // class implement
 
template< class App >
int claw::application::implement<App>::main( int argc, char* argv[] )
{
  App* app = new App( argc, argv );
  app->run();
  delete app;
 
  return EXIT_SUCCESS;
} // application::implement::main()

[YéTeeh]

En C++, main est forcément une fonction libre. C'est aussi une fonction spéciale que tu n'as pas le droit d'appeler toi même. En quoi est-ce gênant ?

Ce n'est pas que je trouve ça gênant, c'est juste que je trouve ça plus joli d'un point de vue design, C'est aussi une façon de m'assurer que je pourrais faire du pré et post traitement, sans que l'utilisateur ait à appeler une méthode init() puis close() ou quelque chose dans le genre.

[Zenol]

Tout ce que je peut te dire, c'est que SDL sous windows fait sa en définissant la fonction WinMain, et ensuite il me semble qu'il apelle la fonction main.

Dans la plus part des gas, il faut utiliser une fonction d'initialisation. Pour voir simple il n'y a que a regarder Qt ^^

[YéTeeh]

Tout ce que je peut te dire, c'est que SDL sous windows fait sa en définissant la fonction WinMain, et ensuite il me semble qu'il apelle la fonction WinMain

wxWidget a une approche similaire. On crée la classe my_app héritant de wxApp, et on l'implémente à l'aide d'une macro. Je ne sais pas trop comment ça se passe derrière, mais je sais qu'on écrit pas de fonction main(). Le truc qui m'embête dans cette approche, c'est l'utilisation de macro, d'un part, et d'autre part, je crois que l'instance de l'application est une variable globale (et je n'aime pas les variables globales ; à la rigueur planquée dans une singleton, mais surtout pas libre).

[Zenol]

A mon avi WxWinget doit tout simplement définir main, créer une instance de ta classe, et l'utiliser

[Médinoc]

En tout cas, je sais que MFC fait la même chose: Définir la fonction WinMain(), qui appelle theApp.InitInstance()...