? ?? Alors la . ...

Bon la fonction Main est le point d´entré de ton programme. Cette fonction est declaré au compilateur ( plus precisement a l´editeur de lien ), comme cela le startup ( montage memoire de ton programme . .. ) peu y faire appel.
Elle est prototypé comme suit :
int main( int argc, void ** argv);
Pof.

Peut t on l´appeler au sein du meme programme :
Oui => rien ne l´interdit ( mis a part vous meme peut etre ). Ce n´est qu´une fonction.

L´ai je deja fait ?
Au grand dieu jaimais ! Faut etre legerement fellé pour faire cela. : -)

Super Dindon :
Le main est une fonction comme les autres ! Pas de magie faite par l´appelant au niveau des registre ! !! Ah !
Personnellement je dirais il y a bien d´autre methode que la recursion !
Desolé mais le controle de la pile n´est pas du ressort du systeme d´exploitation ! Tout ce qu´il fait pour toi c´est t´allouer un espace ( que tu peux forcer a ton edition de lien ) pour ta pile. La gestion est faite en directe live a chaque appel de fonction par les instructions machine ( push-pop etc ) ainsi que par ton compilateur ( recuperation de ESP + Offset ( en fait on passe le plus souvent par EBP - offset mais bon c´est la meme chose ). Le systeme d´exploitation n´a rien a voir avec ceci. Par contre tu peu t´y amuser en declarant une variable sur pile, recupere son adresse et te ballader sur la pile ( mais c´est plus du domaine de la bidouille que de la programmation )

Kelios :
Une fonction peut etre declaré inline dans le . h et ecrite dans le . cpp. C´est l´editeur de lien ( et non le compilateur ) qui se charge de "remplacer" le code machine au moment de ton appel.

Vampire 6 :
Ton test d´arret de recursion c´est kwa ? ??
Le probleme ne vient pas du main mais que t´as laissé ton programme surcharger ta pile par appel recursif ! ! Preuve :

F_Stupide()
{
F_Stupide(); // C´est stupide pasque cela ne s´arrete pas !
}

int main(int , char **)
{
// faut bien l´appeler une fois !
F_Stupide();
}

Te generera les meme erreur ! Mais pourtant le main n´est pas en cause !
Pour ma part j´ai un grand principe pour mes fonctions recusive : Elle commence toujours par leur test d´arret de recursion !
Du style
Somme(int x)
{
// Voici le test d´arret
if(X == 1)
return 1;

// voici la recursion !
return (x+Somme(x-1));
}

Voila !

Ouis... Bon DinDon, jai envie de moccuper de ton cas : 0

Ouais, bon, je ferais mieux de me taire.
Mais je vais continuer quand meme, à mes risques et périls.
===> Ca veut dire que tu savais que tu allais dire de la merde ? ? : )

Pour ce qui est de main, je ne sais pas trop. En fait, il peut y avoir 2 possibilités:
===> Faute avouez, a moitie pardonnee : )

-Soit main nécessite certaines valeurs dans les registres( je parle en Assembleur)(initialisé par le kernel, par exemple, mas je suis pas sur du tout)
===> Y a longtemps que le kernel de LOS ne soccupe plus du demarrage du programmation...A ce stade, c finit. Y a effectivement de linitialisation au demarrage du programme realise avant lappelle de main, mais c le compilateur qui sen occupe... LOS na fait que charger lappli en (creation d un espace de memoire+thread...c deja pas mal ! ) memoire, puis initialise le pointeur dinstruction sur le code du compilateur...qui va par la suite lancer main()... main() ressemble a nimporte quelle autre fonction...

et dans ce cas elle n´est pas récursive sauf si le compilateur a lancé un "push" avant de lancer la fonction main, et là, ça dépend donc totalement du compilo.
===> J ai repondu en avance a cette question... le fameux push a ete appelle par avant la fonction main... Par ailleur, sur certain compilateur, on peut modifier le code situe avant le main...notamment dans les compilateurs pour microcontroleurs.

-Soit main n´a besoin de rien pour se lancer, et elle peut donc etre récursive.
===> Elle a besoin de qqchose, mais elle peut etre recursive.

Je crois qu´il existe des moyens pour controler la pile manuellement dans le sdk win, mais ce sarait une perte de temps...
====> Comme disait passage, la gestion de la pile se fait par le programme....Mais effectivement certaines operations sont controles par lOS, mais je ne sais pas si celleci existe : agrandir la pile en LIVE...La pile est cree lors de la creation du thread...faut regarder dans les parametres du compilateur pour voir si on peut changer la taille de la pile du thread principal...

Bah dit donc, DinDon....qu est ce qui t arrive ? tu es malade ? lol....

Passage-> Pitié pas frapper moi : )

En fait je n´avais pas mis de condition d´arrêt de récursivité tout simplement parce que c´était juste un test sur la récusivité de main.
Au risque de me répéter, je ne ferai jamais une telle chose dans un de mes programmes parce que pour ma part ça ne me serait jamais venu à l´idée et ça me paraîtrait bizarre de faire une telle chose.

Vampire moi pas frapper ki que ce soit.

Juste te dire que ce ce problem n´est pas due a la presence de ton main mais du fait que tu n´avais pas de condition d´arret.

Moi po violent !

Ah non!

On se fait une guéguerre passage? ; P

==================================================
=======================
"Une fonction peut etre declaré inline dans le . h et ecrite dans le . cpp. C´est l´editeur de lien ( et non le compilateur ) qui se charge de "remplacer" le code machine au moment de ton appel. "

->Qui ne savais pas ça? Néamoins, déso de te contreidre, mais:

-"Déclarer une inline et fournir sa définition dans un fichier séparé engendre des références externes sur ces fonctions lors de la compi, et le compilateur n´insérerait pas leur code. Puis, comme si ça ne suiffisait pas, le linker ne fait rien pour ça, puisque les fonctions inlines DOIVENT être insérés sur place."

Voila voila. Après tout, ça justifie les ´.inl´. Hein, c´est vrai, sans ça, que ferait les ´.inl´? Allez, on se fonde le ´Project IDG´! Inline Defense Group! ; P

Kelios
---------

Autant pour moué !

Pardon de l´erreur.

Merci Kelios.

OK, c´est bon, je me tais, Arnaud81...