Propriétés des sous-fonctions

**rodb7** · 02/03/2006, 06h53

Bonjour

J'ai définit dans une fonction plusieurs sous-fonctions, tout marche parfaitement. Seulement, après coup je me rend compte que j'utilise des variables de la fonction principale dans les sous-fonctions sans les passer (aux sous-fonctions...).
Alors est-ce une erreur tolérée par le compilateur ou c'est dans les propriétés des sous-fonctions de pouvoir utiliser des variables de la fonction principale sans pour autant qu'elles leur aient été passées ?!

**Pouic** · 02/03/2006, 07h25

Heu, là, j'aimerai assez voir ton code... Parceque les fonctions imbriquées, en C, c'est pas vraiment toléré...

**nairolf_** · 02/03/2006, 07h26

salut,

En c les variables peuvent avoir differentes portées : Publiques et Privées.

Les variables publiques sont des variables declarée en dehors des fonctions et des procedures (void) de ta source et sont accesibles à partir de n'importe quel partie de ton code.

Les variables privées sont declarée à l'interieur d'une fonction ou d'une procédure et sont accesibles qu'a l'interieur du bloc dans le quelle elles ont été declarée.

c se que tu voulais savoir ?

@++ nairolf

**Emmanuel Delahaye** · 02/03/2006, 08h50

Envoyé par rodb7

J'ai définit dans une fonction plusieurs sous-fonctions,

Pas de 'sous-fonctions' en C. Montre ton code.

**rodb7** · 02/03/2006, 14h32

C'est marrant que vous disiez que ce n'est pas toléré parce que je n'ai aucun warning ou choses du genre et ça a marché de suite... à moins que je désigne intuitivement par "sous-fonction" des choses qui n'en sont pas

:

Quoiqu'il en soit, voici un extrait du code:

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
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
90
91
92
93
94
95
96
97
98
void GameTabAff(int gameSize,int *TabPlay,int nAff)
{
int ctrAL=0;// = compteur d'affichage de ligne, utilisé dans les boucles.
int i=0;
char a='a',carFin[]={'c','d','e','f','g','h','i'};
 
                         void LigneDynamique()
                         {
                          int ctrAL;
                          printf("  ");
                          for(ctrAL=0;ctrAL<gameSize;ctrAL++)
                             {
                              printf("| ");
                              if(nAff==1) 
                                {affSymbol(TabPlay,i);i+=3;}
                              else printf(" ");
                              printf(" |");
                              if(ctrAL<gameSize-1) printf("-");
                             }   
                          printf("  :");     
                         }
                         void Ligne1(int gameSize)
                         {
                          dynamic_spc(gameSize);printf(":::: ");
                          for(ctrAL=0;ctrAL<gameSize;ctrAL++)
                             {
                              color(14);printf("%d",ctrAL+1);color(0);
                              if(ctrAL<gameSize-1) printf("     ");
                             }
                          printf(" ::::");
                         }
                         void Ligne2(int gameSize)
                         {
                          printf("\n");
                          dynamic_spc(gameSize);printf(":");
                          for(ctrAL=0; ctrAL<(23+6*(gameSize-3)-2); printf(" "),ctrAL++);
                          printf(":");
                         }
                         void LigneGenerique(int gameSize)
                         {
                          printf("\n");
                          dynamic_spc(gameSize);printf("    ");
                          for(ctrAL=0;ctrAL<gameSize;ctrAL++)
                             {
                              printf("---   ");
                             }   
                          printf(":");
                         }
                         void Lignei_i(int gameSize)
                         {
                          printf("\n");
                          dynamic_spc(gameSize);printf("   ");
                          color(3);
                          for(ctrAL=0;ctrAL<gameSize;ctrAL++)
                             {
                              printf("  |  ");
                              if(ctrAL<gameSize-1)
                                {
                                 if((ctrAL%2)== 0) printf("\\");
                                 else printf("/");
                                }
                             }
                          color(0);
                          printf("  :");
                         }      
                         void Lignei_p(int gameSize)
                         {
                          printf("\n");
                          dynamic_spc(gameSize);printf("   ");
                          color(3);
                          for(ctrAL=1;ctrAL<=gameSize;ctrAL++)
                             {
                              printf("  |  ");
                              if(ctrAL<=gameSize-1)
                                {
                                 if((ctrAL%2)==0) printf("\\");
                                 else printf("/");
                                }
                             }
                          color(0);
                          printf("  :");
                         }
// Affichage du tableau
Ligne1(gameSize);
Ligne2(gameSize);
for(a;a<=carFin[(gameSize-3)];a++)
 {
  LigneGenerique(gameSize);
  printf("\n"); dynamic_spc(gameSize);color(14);printf("%c",a);color(0);LigneDynamique();  LigneGenerique(gameSize);
    if(a<carFin[(gameSize-3)])
      {
       if(a%2==0) Lignei_p(gameSize);
          else    Lignei_i(gameSize);
      }     
 }
Ligne2(gameSize); printf("\n");
Ligne1(gameSize);
}

Bon, pour expliquer un peu, il s'agit d'une fonction dans un programme permettant d'afficher un tableau de taille variable (gameSize) entrée par l'utilisateur et d'afficher aux coordonnées voulues le symbole du joueur.
Comme vous pouvez le voir, j'utilise dans toutes les 'sous-fonctions' la variable ctrAL sans qu'elle n'y soit jamais déclarée et dans la 'sous-fonction' LigneDynamique() ben... y a rien de passé...
Le "problème"(mais ça me dérange pas trop en fait) c'est que ça fonctionne très bien sans génrérer de warning ou autre.

Bref, sous-fonction, pas sous-fonction, pourquoi pas probleme ?

**Emmanuel Delahaye** · 02/03/2006, 14h50

Envoyé par rodb7

C'est marrant que vous disiez que ce n'est pas toléré parce que je n'ai aucun warning ou choses du genre et ça a marché de suite...

Arf !

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
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
 
Compiling: main.c
main.c:7: warning: no previous prototype for 'GameTabAff'
main.c: In function `GameTabAff':
main.c:13: warning: function declaration isn't a prototype
main.c: In function `LigneDynamique':
main.c:14: warning: declaration of 'ctrAL' shadows a previous local
main.c:8: warning: shadowed declaration is here
main.c:15: error: implicit declaration of function `printf'
main.c:15: warning: nested extern declaration of `printf'
<internal>:0: warning: redundant redeclaration of 'printf'
main.c:20: error: implicit declaration of function `affSymbol'
main.c:20: warning: nested extern declaration of `affSymbol'
main.c: In function `GameTabAff':
main.c:27: warning: declaration of 'gameSize' shadows a parameter
main.c:6: warning: shadowed declaration is here
main.c:28: warning: no previous prototype for 'Ligne1'
main.c: In function `Ligne1':
main.c:29: error: implicit declaration of function `dynamic_spc'
main.c:29: warning: nested extern declaration of `dynamic_spc'
main.c:29: warning: nested extern declaration of `printf'
<internal>:0: warning: redundant redeclaration of 'printf'
main.c:32: error: implicit declaration of function `color'
main.c:32: warning: nested extern declaration of `color'
main.c: In function `GameTabAff':
main.c:37: warning: declaration of 'gameSize' shadows a parameter
main.c:6: warning: shadowed declaration is here
main.c:38: warning: no previous prototype for 'Ligne2'
main.c: In function `Ligne2':
main.c:39: warning: nested extern declaration of `printf'
<internal>:0: warning: redundant redeclaration of 'printf'
main.c:40: warning: nested extern declaration of `dynamic_spc'
main.c:29: warning: redundant redeclaration of 'dynamic_spc'
main.c:29: warning: previous implicit declaration of 'dynamic_spc' was here
main.c: In function `GameTabAff':
main.c:44: warning: declaration of 'gameSize' shadows a parameter
main.c:6: warning: shadowed declaration is here
main.c:45: warning: no previous prototype for 'LigneGenerique'
main.c: In function `LigneGenerique':
main.c:46: warning: nested extern declaration of `printf'
<internal>:0: warning: redundant redeclaration of 'printf'
main.c:47: warning: nested extern declaration of `dynamic_spc'
main.c:29: warning: redundant redeclaration of 'dynamic_spc'
main.c:29: warning: previous implicit declaration of 'dynamic_spc' was here
main.c: In function `GameTabAff':
main.c:54: warning: declaration of 'gameSize' shadows a parameter
main.c:6: warning: shadowed declaration is here
main.c:55: warning: no previous prototype for 'Lignei_i'
main.c: In function `Lignei_i':
main.c:56: warning: nested extern declaration of `printf'
<internal>:0: warning: redundant redeclaration of 'printf'
main.c:57: warning: nested extern declaration of `dynamic_spc'
main.c:29: warning: redundant redeclaration of 'dynamic_spc'
main.c:29: warning: previous implicit declaration of 'dynamic_spc' was here
main.c:58: warning: nested extern declaration of `color'
main.c:32: warning: redundant redeclaration of 'color'
main.c:32: warning: previous implicit declaration of 'color' was here
main.c: In function `GameTabAff':
main.c:71: warning: declaration of 'gameSize' shadows a parameter
main.c:6: warning: shadowed declaration is here
main.c:72: warning: no previous prototype for 'Lignei_p'
main.c: In function `Lignei_p':
main.c:73: warning: nested extern declaration of `printf'
<internal>:0: warning: redundant redeclaration of 'printf'
main.c:74: warning: nested extern declaration of `dynamic_spc'
main.c:29: warning: redundant redeclaration of 'dynamic_spc'
main.c:29: warning: previous implicit declaration of 'dynamic_spc' was here
main.c:75: warning: nested extern declaration of `color'
main.c:32: warning: redundant redeclaration of 'color'
main.c:32: warning: previous implicit declaration of 'color' was here
main.c: In function `GameTabAff':
main.c:94: warning: nested extern declaration of `printf'
<internal>:0: warning: redundant redeclaration of 'printf'
main.c:94: warning: nested extern declaration of `dynamic_spc'
main.c:29: warning: redundant redeclaration of 'dynamic_spc'
main.c:29: warning: previous implicit declaration of 'dynamic_spc' was here
main.c:94: warning: nested extern declaration of `color'
main.c:32: warning: redundant redeclaration of 'color'
main.c:32: warning: previous implicit declaration of 'color' was here
main.c:101: warning: nested extern declaration of `printf'
<internal>:0: warning: redundant redeclaration of 'printf'
main.c:91: warning: statement with no effect
Process terminated with status 1 (0 minutes, 1 seconds)

C'est une extension de gcc. Ce n'est pas standard.

**rodb7** · 02/03/2006, 15h01

Oula

Je dois faire quoi là alors ? Comment gcc peut me compiler ça sans même mettre un warning(j'utilise devCpp) !!

Je suis un peu sur le luc là, je ne me serais pas posé la question que ça serait passé inaperçu...

Quel compilateur avez-vous utilisé Emmanuel ?

**Médinoc** · 02/03/2006, 15h07

gcc aussi, mais gcc a la (très) facheuse habitude de ne donner aucun warning si on ne le lui demande pas explicitement.

Moi, je compile avec ces options de warning:
-Wall -Wextra -Wwrite-strings -O2
(Il faut rajouter -O avec un chiffre assez élevé pour certains warnings qui n'apparaissent que si gcc essaie d'optimiser le code. Notamment, tous les "uninitialized variable").

**rodb7** · 02/03/2006, 15h43

Mais comment se fait-il que ça fonctionne ??
C'est vraiment une grosse erreur ou alors(et puisque c'est toléré visiblement) je peux laisser comme ça ? Niveau clarté du code dans ce cas je trouve les sous-fonctions vraiment bien.

**HRS** · 02/03/2006, 15h45

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
#include <stdio.h>
int main (void) {
    int titi = 3;
    void Affiche (void) {
         printf ("%d\n",titi);
    }
    Affiche ();
    getchar();
    return 0;
}

c'est vrai que cela marche sans warning avec le MinGW (même avec les options -Wall -Wextra -Wwrite-strings -O2)

l'imbrication de fonctions/procédures est courante en Pascal mais pas
enseignée en C

Mais est-ce vraiment illégal ? la permissivité du C est incommensurable.

Que dit la norme ? Si l'imbrication n'est pas dans la norme, il ne faut pas
l'employer, même si tel compilateur l'autorise.

**Trap D** · 02/03/2006, 15h51

Je ne connaissais pas cette possiblité en C.
Sous Visual C, ça ne compile pas, donc au minimum, ce n'est pas portable.

**Emmanuel Delahaye** · 02/03/2006, 16h36

Envoyé par Trap D

Je ne connaissais pas cette possiblité en C.
Sous Visual C, ça ne compile pas, donc au minimum, ce n'est pas portable.

Je me tue à le dire, c'est une extension de gcc. Ce n'est pas portable. Pour désactiver les extensions, il faut compiler en mode ansi.

Code :

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

-ansi

ou

Code :

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

-std=c99

**rodb7** · 02/03/2006, 16h43

Qu'est ce que tu veux dire concrètement par " c'est une extension de gcc " ?
Ca entraine quoi pour l'ensemble du code ?

**Emmanuel Delahaye** · 02/03/2006, 16h50

Envoyé par rodb7

Qu'est ce que tu veux dire concrètement par " c'est une extension de gcc " ?
Ca entraine quoi pour l'ensemble du code ?

Je crois que Trap D t'a donné la réponse :

Sous Visual C, ça ne compile pas, donc au minimum, ce n'est pas portable.

Si ton code est compilé avec un autre compilateur, ça risque de ne pas compiler, ou pire, de compiler mais de fonctionner d'une manière différente de celle définie par gcc.

En l'occurence, je ne vois pas à quoi servent les fonctions imbriquées. Si tu veux des fonctions à portées réduites, définie les 'static'.

http://emmanuel-delahaye.developpez....tes.htm#portee

Les extensions sont utiles dans certains cas, mais elles rendent le code non portable.
Il faut le savoir, c'est tout.

D'autre part, ici, on s'interesse plutôt au code portable (j'ai pas envie de modifier ma config pour tester du code non portable...)

**rodb7** · 02/03/2006, 18h55

En l'occurence, je ne vois pas à quoi servent les fonctions imbriquées. Si tu veux des fonctions à portées réduites, définie les 'static'.

http://emmanuel-delahaye.developpez....tes.htm#portee

Je ne comprend pas trop ce que tu veux dire. Dans tes notes tu parles d'unité de compilation, et en C l'unité de compilation est bien le fichier ? Dans la mesure où mon code tiens en un seul fichier... enfin je ne saisit vraiment pas.
Je pense que je vais garder le code tel qu'il est dans un premier temps. Ce n'est peut-être ni standard ni portable mais cette extension donne la liberté a une certaine intuition(utiliser des sous-fonctions dans ce cas a l'air plutôt évident à mes yeux) et c'est pas plus mal.

Merci pour toutes vos réponses.

**gege2061** · 02/03/2006, 19h08

Bonjour,

Envoyé par rodb7

Ce n'est peut-être ni standard ni portable mais cette extension donne la liberté a une certaine intuition(utiliser des sous-fonctions dans ce cas a l'air plutôt évident à mes yeux) et c'est pas plus mal.

Ce n'est pas une obligation de faire du code standard ou portable, tant que tu fais ce choix délibérément et que tu en connais les conséquences.

**HanLee** · 04/03/2006, 15h44

Envoyé par Emmanuel Delahaye

En l'occurence, je ne vois pas à quoi servent les fonctions imbriquées. Si tu veux des fonctions à portées réduites, définie les 'static'.

Dans ce cas là, autant ne pas utiliser de variables locales...

Ca sert à ne pas avoir une procédure/fonction qui se balade dans un fichier, qui ne sert qu'à un seul algorithme, et qui ne sert à rien d'autre.

Après tout une fonction, c'est comme une donnée comme n'importe quelle autre. Les gens considèrent bien les fonctions comme des vecteurs.

**Emmanuel Delahaye** · 04/03/2006, 16h03

Envoyé par HanLee

Ca sert à ne pas avoir une procédure/fonction qui se balade dans un fichier, qui ne sert qu'à un seul algorithme, et qui ne sert à rien d'autre.

Après tout une fonction, c'est comme une donnée comme n'importe quelle autre. Les gens considèrent bien les fonctions comme des vecteurs.

Gné ? Grave erreur... Oui, le C est orienté traitement, ok, mais un peu d'orientation objet ne fait pas de mal. Dans ce cas, ce sont les fonctions qui deviennent les points d'entrée visibles.

Je ne suis pas complètement contre le principe des fonctions locales (ok, ça existe en Turbo-Pascal), mais le problème est que ça rend le code gravement non portable (gcc est certes répandu, mais encore unique, et heureusement. Monopole, on merci...) La norme reste la référence et le comité est en sommeil, ça ne risque plus de bouger avant 50 ans...

Evidemment, si on écrit en GNU-C, c'est autre chose, mais ce n'est plus du C. C'est un autre langage (comme Pascal vs Turbo-Pascal).

**Tellmarch** · 04/03/2006, 16h15

J'ai entendu parler de ça, je crois que ça a été rajouté récement dans gcc, avant ce n'était pas autorisé...
Si tu es sur que ton programmes ne sera jamais compilé par quelqu'un qui n'utilisera pas le meme compilateur que toi, ça ne posera pas de probleme.

Dans ce cas, les variables de la fonction englobante sont effectivement accessibles dans les sous-fonctions (meme systeme qu'en pascal par exemple).

Par contre si tu envisages que quelqu'un d'autre utilise tes sources, c'est mieux d'éviter d'utiliser des sous-fonctions.

**HanLee** · 04/03/2006, 16h15

Envoyé par Emmanuel Delahaye

Envoyé par HanLee

Ca sert à ne pas avoir une procédure/fonction qui se balade dans un fichier, qui ne sert qu'à un seul algorithme, et qui ne sert à rien d'autre.

Après tout une fonction, c'est comme une donnée comme n'importe quelle autre. Les gens considèrent bien les fonctions comme des vecteurs.

Gné ? Grave erreur... Oui, le C est orienté traitement, ok, mais un peu d'orientation objet ne fait pas de mal. Dans ce cas, ce sont les fonctions qui deviennent les points d'entrée visibles.

Je ne suis pas complètement contre le principe des fonctions locales (ok, ça existe en Turbo-Pascal), mais le problème est que ça rend le code gravement non portable (gcc est certes répandu, mais encore unique, et heureusement. Monopole, on merci...) La norme reste la référence et le comité est en sommeil, ça ne risque plus de bouger avant 50 ans...

Evidemment, si on écrit en GNU-C, c'est autre chose, mais ce n'est plus du C. C'est un autre langage (comme Pascal vs Turbo-Pascal).

Ah non mais j'l'encourage pas à faire du code comme ça rassure toi, moi j'veux qu'il t'écoute, c'est-à-dire qu'il code portable.

C'est juste que ça m'a gêné que tu dises que ça ne présente pas grand intérêt.

Par contre s'il compte coder pour lui, il fait comme il veut

.

Sinon, moi j'trouve que ça fait plutôt orienté fonctionnel que traitement.

Propriétés des sous-fonctions

C

Discussions similaires

Partager

Partager