(je suis débutant en c) je ne vois d'instruction pour boucler

Le Wed, 25 Nov 2009 16:33:52 -0800 (PST),
"bpascal123@googlemail.com" <bpascal123@googlemail.com> a écrit :

Bjr,sr,
Voici une fonction très simple qui réagit comme s'il y avait une
boucle alors qu'en apparence il n'y en a pas :

Bis. Même constat et réponse que précédemment.

--
Jacques.

Le Wed, 25 Nov 2009 16:33:52 -0800 (PST)
bpascal123@googlemail.com a écrit

Bjr,sr,
Voici une fonction très simple qui réagit comme s'il y avait une
boucle alors qu'en apparence il n'y en a pas :

#include <stdio.h>

void f2(int b);
void f1(int a);

int main(void)
{
f1(30);

return 0;
}

void f1(int a)
{
if( a )
f2( a - 1 );
printf("%d ", a);
}

void f2(int b)
{
printf(" . ");
if(b)
f1( b - 1 );
}

http://www.java2s.com/Code/C/Function/Functioncalleachother.htm

Merci,
Pascal

Tu viens de découvrir la *récursivité*

En voilà un autre exemple plus imbriqué encore, la courbe de Hilbert
en mode tortue style logo : fcap(0); d(n);

/* -------------------------------------------------------- */
void d(int n);
void h(int n);
void b(int n);
void g(int n);

void d(int n)
{
if(n==0) return;

if(n>0)
{
h(n-1); fcap(K_NORD); av(2);
d(n-1); fcap(K_EST); av(2);
d(n-1); fcap(K_SUD); av(2);
b(n-1);
}

if(n>=6) flush_videobuf();
}

/* -------------------------------------------------------- */
void h(int n)
{
if(n==0) return;

if(n>0)
{
d(n-1); fcap(K_EST); av(2);
h(n-1); fcap(K_NORD); av(2);
h(n-1); fcap(K_OUEST); av(2);
g(n-1);
}
}

/* -------------------------------------------------------- */
void b(int n)
{
if(n==0) return;

if(n>0)
{
g(n-1); fcap(K_OUEST); av(2);
b(n-1); fcap(K_SUD); av(2);
b(n-1); fcap(K_EST); av(2);
d(n-1);
}
}

/* -------------------------------------------------------- */
void g(int n)
{
if(n==0) return;

if(n>0)
{
b(n-1); fcap(K_SUD); av(2);
g(n-1); fcap(K_OUEST); av(2);
g(n-1); fcap(K_NORD); av(2);
h(n-1);
}
}

--
zwim.
Rien n'est impossible que la mesure de la volonté humaine...

Merci zwim,

J'avais le sentiment de quelque chose de récursif dans le résultat
mais je n'ai pas encore abordé le chapitre des fonctions en tant
qu'autodidacte en programmation. En plus, le site d'où le code vient
n'abuse pas des commentaires. Je pense ils ont juste balancé du code
de différents langages pour ceux qui ont déjà de bonnes bases.

Pour ton code, la récursivité est plus apparente que le code que j'ai
posté dans le sens qu'à l'intérieur d'une fonction, tu appelles cette
fonction : void g(int n) { ... g(n-1); ...}

Je comprendrais certainement mieux quand j'aborderais le chapitre des
fonctions.

Merci,
Pascal

bpascal123@googlemail.com a écrit :

J'avais le sentiment de quelque chose de récursif dans le résultat
mais je n'ai pas encore abordé le chapitre des fonctions en tant
qu'autodidacte en programmation.

Tu n'as pas abordé la question des fonctions en C et tu as ouvert un fil
sur fgets() ? c'est pas vraiment logique, apprendre c'est comme une
recette de cuisine, il suffit pas d'avoir les bons ingrédients faut
aussi les utiliser dans le bon ordre ;) Faut reconnaître aussi que les
livres ne sont pas un modèle de logique en la matière.

Pour ton code, la récursivité est plus apparente que le code que j'ai
posté dans le sens qu'à l'intérieur d'une fonction, tu appelles cette
fonction : void g(int n) { ... g(n-1); ...}

C'est de la récursivité croisée. Franchement, le code donné est très
artificiel, c'est vraiment un exercice de style et qui ne sert quasiment
jamais dans la pratique, le genre de code qui n'a pour effet que de
décourager le débutant et lui faire prendre la proie pour l'ombre.

Je comprendrais certainement mieux quand j'aborderais le chapitre des
fonctions.

Il y a plein de programmeurs C (C ou autre) qui n'ont jamais rien
compris à la récursivité donc te crois pas obligé de passer par ce
pensum (qui est aussi une belle tarte à la crème).

On 26 nov, 01:33, "bpascal...@googlemail.com"
<bpascal...@googlemail.com> wrote:

Bjr,sr,
Voici une fonction très simple qui réagit comme s'il y avait une
boucle alors qu'en apparence il n'y en a pas :

C'est un appel récursif. Ça se comporte comme une boucle, oui, c'est
fait pour ...

Ça n'a rien de 'très simple'...

candide a écrit :

Il y a plein de programmeurs C (C ou autre) qui n'ont jamais rien
compris à la récursivité donc te crois pas obligé de passer par ce
pensum (qui est aussi une belle tarte à la crème).

J'ai du mal à comprendre qu'on puisse se prétendre programmeur et ne
rien entendre à la récursivité. Les pointeurs, à la rigueur, je peux
comprendre, mais la récursivité ?

--
Mickaël Wolff aka Lupus Michaelis
http://lupusmic.org

Mickaël Wolff a écrit :

candide a écrit :

Il y a plein de programmeurs C (C ou autre) qui n'ont jamais rien
compris à la récursivité donc te crois pas obligé de passer par ce
pensum (qui est aussi une belle tarte à la crème).

J'ai du mal à comprendre qu'on puisse se prétendre programmeur et ne
rien entendre à la récursivité. Les pointeurs, à la rigueur, je peux
comprendre, mais la récursivité ?

Moi aussi. Sans la récursivité, fini les structures d'arbres et autres
structures de données "sophistiquées".

Souvent la récursivité permet de coder avec peu de ligne des algos qui
s'ils sont "dérécursivisés" deviennent super lourds à écrire, gérer,
maitenir et qui nécéssitent du support du Runtime ou de l'OS tel que
l'allocation de mémoire dynamique.

Dans mon domaine (l'embarqué), les OS n'ont pas toujours d'allocation
mémoire dynamique mais ils supportent tous une pile (pour appeller des
fonctions il vaut mieux), et dans ce cas la version récursive des algos
est préférable à celle qui fait des "malloc()".

Cela dit, dans ce domaine il faut se méfier de la taille de ce que l'on
envoi sur la pile car cette dernière n'est pas non plus toujours très
grande (256octets à 1k parfois), mais cela permet quand même de
travailler sur des structures de données réalistes avec une profondeur
raisonnable. En effet si on empile 8 octets à chaque appel (un pointeur
de data et l'adresse de retour par exemple), alors il faut a peu près
une profondeur de 32 avant de saturer les 256 octets de pile. C'est pas
mal du tout finalement.

sam.

> Tu n'as pas abordé la question des fonctions en C et tu as ouvert un fi l
sur fgets() ? c'est pas vraiment logique, apprendre c'est comme une
recette de cuisine, il suffit pas d'avoir les bons ingrédients faut
aussi les utiliser dans le bon ordre ;) Faut reconnaître aussi que les
livres ne sont pas un modèle de logique en la matière.

A mon niveau, je distingue les fonctions "toutes faites" qui vont avec
stdio.h, string.h ... des fonctions que l'on "fabrique" avec
prototype, déclaration, définition... Je ne suis pas entièrement sû re
de ce que je dis mais je pense que ça explique en tant que débutant,
j'ai commencé avec les fonctions des librairies standards.

On 26 nov, 13:26, "bpascal...@googlemail.com"
<bpascal...@googlemail.com> wrote:

A mon niveau, je distingue les fonctions "toutes faites" qui vont avec
stdio.h, string.h ... des fonctions que l'on "fabrique" avec
prototype, déclaration, définition... Je ne suis pas entièrement s ûre
de ce que je dis mais je pense que ça explique en tant que débutant,
j'ai commencé avec les fonctions des librairies standards.

Et tu as tout à fait raison... J'ai failli répondre directement à
Candide, mais j'ai préféré que ça vienne de toi !

-ed- a écrit :

On 26 nov, 13:26, "bpascal...@googlemail.com"
<bpascal...@googlemail.com> wrote:

A mon niveau, je distingue les fonctions "toutes faites" qui vont avec
stdio.h, string.h ... des fonctions que l'on "fabrique" avec
prototype, déclaration, définition... Je ne suis pas entièrement sûre
de ce que je dis mais je pense que ça explique en tant que débutant,
j'ai commencé avec les fonctions des librairies standards.

Et tu as tout à fait raison...

si son but est de ne pas arriver à apprendre le C, il est effectivement
sur la bonne voie.