Créer une fonction récursive

Version imprimable

Bonjour,

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

Code:

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);
}

06/04/2013, 21h10
Médinoc

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

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

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:

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);
}

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

Code:

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);
}

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

Code:

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:

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);
}