Créer une fonction récursive

**sourcilpower** · 06/04/2013, 15h56

Bonjour,

J'aime savoir si c'est possible et comment faire une recursive avec le bout de code suivant svp

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "../my.h"
 
int     main()
{
  int   pipefd[2];
  int   pid;
 
  xpipe(pipefd);
  pid = xfork();
  if (pid == 0)
    {
      xclose(pipefd[0]);
      xdup2(pipefd[1], 1);
      execlp("/bin/ls", "ls", "-la",  0);
    }
  else
    {
      xclose(pipefd[1]);
      xdup2(pipefd[0], 0);
      xpipe(pipefd);
      pid = xfork();
      if (pid == 0)
        {
          xclose(pipefd[0]);
          xdup2(pipefd[1], 1);
          execlp("/bin/cat", "cat", "-e", 0);
        }
      else
        {
          xclose(pipefd[1]);
          xdup2(pipefd[0], 0);
          xpipe(pipefd);
          pid = xfork();
          if (pid == 0)
            {
              xclose(pipefd[0]);
              xdup2(pipefd[1], 1);
              execlp("/bin/grep", "grep", "test", 0);
            }
          else
            {
              xclose(pipefd[1]);
              xdup2(pipefd[0], 0);
              execlp("/bin/cat", "cat", "-b", 0);
            }
        }
    }
  return (EXIT_SUCCESS);
}

**Médinoc** · 06/04/2013, 21h10

Bonjour,
"faire une recursive" ne veut rien dire.

Aussi, tu devrais séparer ton code en plusieurs fonctions, ce serait plus lisible.

**Médinoc** · 06/04/2013, 21h29

Tiens, voici le même code avec des fonctions marquant bien à chaque fois qui fait quoi.
On en profite pour utiliser les macros STDxxx_FILENO à la place de nombres magiques, et d'écrire nos propres macros pour les pipes (là encore pour éviter les nombres magiques).

Code C :

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "../my.h"
 
#define PIPEFD_READ 0
#define PIPEFD_WRITE 1
 
void fils1(int pipefd1[]);
void fils2(int pipefd2[]);
void fils3(int pipefd3[]);
 
void pere1(int pipefd1[]);
void pere2(int pipefd2[]);
void pere3(int pipefd3[]);
 
void fils1(int pipefd1[])
{
	xclose(pipefd1[PIPEFD_READ]);
	xdup2(pipefd1[PIPEFD_WRITE], STDOUT_FILENO);
	execlp("/bin/ls", "ls", "-la",  0);
}
void pere1(int pipefd1[])
{
	int pipefd2[2];
	int pid;
	xclose(pipefd1[PIPEFD_WRITE]);
	xdup2(pipefd1[PIPEFD_READ], STDIN_FILENO);
 
	xpipe(pipefd2);
	pid = xfork();
	if (pid == 0)
		fils2(pipefd2);
	else
		pere2(pipefd2);
}
 
void fils2(int pipefd2[])
{
	xclose(pipefd2[PIPEFD_READ]);
	xdup2(pipefd2[PIPEFD_WRITE], STDOUT_FILENO);
	execlp("/bin/cat", "cat", "-e", 0);
}
void pere2(int pipefd2[])
{
	int pipefd3[2];
	int pid;
	xclose(pipefd2[PIPEFD_WRITE]);
	xdup2(pipefd2[PIPEFD_READ], STDIN_FILENO);
 
	xpipe(pipefd3);
	pid = xfork();
	if (pid == 0)
		fils3(pipefd3);
	else
		pere3(pipefd3);
}
 
void fils3(int pipefd3[])
{
	xclose(pipefd3[PIPEFD_READ]);
	xdup2(pipefd3[PIPEFD_WRITE], STDOUT_FILENO);
	execlp("/bin/grep", "grep", "test", 0);
}
void pere3(int pipefd3[])
{
	xclose(pipefd3[PIPEFD_WRITE]);
	xdup2(pipefd3[PIPEFD_READ], STDIN_FILENO);
	execlp("/bin/cat", "cat", "-b", 0);
}
 
int main(void)
{
	int   pipefd1[2];
	int   pid;
 
	xpipe(pipefd1);
	pid = xfork();
	if (pid == 0)
		fils1(pipefd1);
	else
		pere1(pipefd1);
	return (EXIT_SUCCESS);
}

**Médinoc** · 06/04/2013, 21h34

Puis on se rend compte qu'on peut faire plus compréhensible encore en regroupant les manips sur les pipes dans des fonctions:

Code C :

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
void pipe_en_sortie_standard(int pipefd[])
{
	xclose(pipefd[PIPEFD_READ]);
	xdup2(pipefd[PIPEFD_WRITE], STDOUT_FILENO);
}
void pipe_en_entree_standard(int pipefd[])
{
	xclose(pipefd[PIPEFD_WRITE]);
	xdup2(pipefd[PIPEFD_READ], STDIN_FILENO);
}
 
void fils1(int pipefd1[])
{
	pipe_en_sortie_standard(pipefd1);
	execlp("/bin/ls", "ls", "-la",  0);
}
void pere1(int pipefd1[])
{
	int pipefd2[2];
	int pid;
	pipe_en_entree_standard(pipefd1);
 
	xpipe(pipefd2);
	pid = xfork();
	if (pid == 0)
		fils2(pipefd2);
	else
		pere2(pipefd2);
}
 
void fils2(int pipefd2[])
{
	pipe_en_sortie_standard(pipefd2);
	execlp("/bin/cat", "cat", "-e", 0);
}
void pere2(int pipefd2[])
{
	int pipefd3[2];
	int pid;
	pipe_en_entree_standard(pipefd2);
 
	xpipe(pipefd3);
	pid = xfork();
	if (pid == 0)
		fils3(pipefd3);
	else
		pere3(pipefd3);
}
 
void fils3(int pipefd3[])
{
	pipe_en_sortie_standard(pipefd3);
	execlp("/bin/grep", "grep", "test", 0);
}
void pere3(int pipefd3[])
{
	pipe_en_entree_standard(pipefd3);
	execlp("/bin/cat", "cat", "-b", 0);
}

**Médinoc** · 06/04/2013, 21h48

L'étape suivante, c'est de mettre la gestion des pipes directement dans la fonction de fork:

Code C :

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "../my.h"
 
#define PIPEFD_READ 0
#define PIPEFD_WRITE 1
 
void fils1();
void fils2();
void fils3();
 
void pere1();
void pere2();
void pere3();
 
void pipe_en_sortie_standard(int pipefd[])
{
	xclose(pipefd[PIPEFD_READ]);
	xdup2(pipefd[PIPEFD_WRITE], STDOUT_FILENO);
}
void pipe_en_entree_standard(int pipefd[])
{
	xclose(pipefd[PIPEFD_WRITE]);
	xdup2(pipefd[PIPEFD_READ], STDIN_FILENO);
}
 
int fork_fils_ecrit_pere_lit(void)
{
	int pipefd[2];
	int pidFils = xfork();
	if(pidFils==0)
	{
		/*Fils: On écrit*/
		pipe_en_sortie_standard(pipefd);
	}
	else
	{
		/*Père: On lit*/
		pipe_en_entree_standard(pipefd);
	}
	return pidFils;
}
 
 
void fils1()
{
	execlp("/bin/ls", "ls", "-la",  0);
}
void pere1()
{
	int pidFils2 = fork_fils_ecrit_pere_lit();
	if (pidFils2 == 0)
		fils2();
	else
		pere2();
}
 
void fils2()
{
	execlp("/bin/cat", "cat", "-e", 0);
}
void pere2()
{
	int pidFils3 = fork_fils_ecrit_pere_lit();
	if (pidFils3 == 0)
		fils3();
	else
		pere3();
}
 
void fils3()
{
	execlp("/bin/grep", "grep", "test", 0);
}
void pere3()
{
	execlp("/bin/cat", "cat", "-b", 0);
}
 
int main(void)
{
	int pidFils1 = fork_fils_ecrit_pere_lit();
	if (pidFils1 == 0)
		fils1();
	else
		pere1();
	return (EXIT_SUCCESS);
}

Et là, on se rend compte qu'on a tellement simplifié les fonctions qu'on peut revenir à un gros main():

Code C :

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "../my.h"
 
#define PIPEFD_READ 0
#define PIPEFD_WRITE 1
 
void pipe_en_sortie_standard(int pipefd[])
{
	xclose(pipefd[PIPEFD_READ]);
	xdup2(pipefd[PIPEFD_WRITE], STDOUT_FILENO);
}
void pipe_en_entree_standard(int pipefd[])
{
	xclose(pipefd[PIPEFD_WRITE]);
	xdup2(pipefd[PIPEFD_READ], STDIN_FILENO);
}
 
int fork_fils_ecrit_pere_lit(void)
{
	int pipefd[2];
	int pidFils = xfork();
	if(pidFils==0)
	{
		/*Fils: On écrit*/
		pipe_en_sortie_standard(pipefd);
	}
	else
	{
		/*Père: On lit*/
		pipe_en_entree_standard(pipefd);
	}
	return pidFils;
}
 
 
int main(void)
{
	int pidFils1 = fork_fils_ecrit_pere_lit();
	if(pidFils1 == 0)
	{
		/*Fils 1: Lit sur le disque et envoie à Père 1*/
		execlp("/bin/ls", "ls", "-la",  0);
	}
	else
	{
		int pidFils2 = fork_fils_ecrit_pere_lit();
		if (pidFils2 == 0)
		{
			/*Fils 2: Reçoit de Fils 1 et envoie à Père 2*/
			execlp("/bin/cat", "cat", "-e", 0);
		}
		else
		{
			int pidFils3 = fork_fils_ecrit_pere_lit();
			if (pidFils3 == 0)
			{
				/*Fils 3: Reçoit de Fils 2 et envoie à Père 3*/
				execlp("/bin/grep", "grep", "test", 0);
			}
			else
			{
				/*Père 3: Reçoit de Fils 3 et envoie à la sortie standard*/
				execlp("/bin/cat", "cat", "-b", 0);
			}
		}
	}
	return (EXIT_SUCCESS);
}

Créer une fonction récursive

C

Discussions similaires

Partager

Partager