structures de données en paramètres, définitions et déclarations

Version imprimable

16/01/2007, 17h38
kromartien

structures de données en paramètres, définitions et déclarations
Bonjour. J'ai un problème lorsque je veux écrire un programme en C ayant un algorithme apparenté au jeu de la vie. J'aimerai avoir des précisions sur quelques difficultés syntaxiques :

*Dans le programme, j'écris les prototypes de fonction à l'intérieur et au début du main, si bien que j'ai quelque chose qui ressemble à ça :
Code:

1 2 3 4 5 6 int main(void) { int fonction1(int,double); double fonction2(int,double); ....
Est ce bien correct ?

*J'écris les définitions de fonction après le main, si bien que j'ai quelque chose du genre :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 int main(void) { int carre(int,int); ... return 0; } int carre(int a, int b) { return a*b; }
Est ce bien correct ?

*Enfin, et je crois que c'est mon plus gros problème, j'ai du mal dans la manipulation des structures (passage par valeur, déclaration de nouvelles variable de type structure, ...)

La déclaration d'un nouveau type de structure par
Code:

1 2 3 4 5 6 7 struct ma_structure { int champ1; double champ2; ... };
1) est-elle correcte ?
2) Cela se fait-il dans le main (début) ou à l'extérieur du main (début ou fin ?), en particulier dans le cas de fonctions définies à l'extérieur du main manipulant des objets de type ma_structure ?

Pour terminer, j'aimerai savoir comment utiliser le nouveau type créé. Doit on écrire dans le cas de la création d'un nouvel objet de type ma_structure
Code:

1 2 struct ma_structure objet1;
ou bien
Code:

1 2 ma_structure objet1;
?

De même, lorsque ce type est manipulé par des fonctions, comment doit on écrire prototype et définition :

prototype ?
Code:

1 2 struct ma_structure une_fonction(struct ma_structure);
ou
Code:

1 2 ma_structure une_fonction(ma_structure);
définition?
Code:

1 2 3 4 5 struct ma_structure une_fonction(struc ma_structure objet1) { ... }
ou
Code:

1 2 3 4 5 ma_structure une_fonction(ma_structure objet1) { ... }
Merci beaucoup de bien vouloir éclairer ma lanterne.
16/01/2007, 18h22
diogene
Citation:

*Dans le programme, j'écris les prototypes de fonction à l'intérieur et au début du main, si bien que j'ai quelque chose qui ressemble à ça :

C'est possible, mais pas courant puisque le prototype ne sera connu qu'après sa déclaration donc tardivement à moins de placer le main en premier. On préfère placer les prototypes en tête du fichier pour pouvoir utiliser les fonctions "à tout moment"

Citation:

J'écris les définitions de fonction après le main, si bien que j'ai quelque chose du genre :

C'est possible avant ou après. Mais si les prototypes sont dans le main et les fonctions avant le main, les prototypes ne servent plus à rien. Avec les prototypes en tête de fichier, l'ordre des fonctions (y compris main) est indifférent.

Citation:

La déclaration d'un nouveau type de structure par
struct ma_structure
{
int champ1;
double champ2;
...
};
1) est-elle correcte ?

Oui

Citation:

2) Cela se fait-il dans le main (début) ou à l'extérieur du main (début ou fin ?), en particulier dans le cas de fonctions définies à l'extérieur du main manipulant des objets de type ma_structure

En tête du fichier avant les prototypes si ils utilisent ce type. De toute façon, en dehors du main (sinon elle ne sera pas connue à l'extérieur de main)

Citation:

Pour terminer, j'aimerai savoir comment utiliser le nouveau type créé. Doit on écrire dans le cas de la création d'un nouvel objet de type ma_structure
struct ma_structure objet1;

Oui

Citation:

De même, lorsque ce type est manipulé par des fonctions, comment doit on écrire prototype et définition :
prototype ?
struct ma_structure une_fonction(struct ma_structure);

Oui
Pour se "dispenser" du mot struct, définir un nouveau type :
Code:

1 2 3 4 5 6 typedef struct { int champ1; double champ2; ... }ma_structure;

Salut,

La réponse à beaucoup de tes questions se trouvent dans n'importe bouquin de C. Voici quelques éléments de réponse:
Citation:
Envoyé par kromartien
*Dans le programme, j'écris les prototypes de fonction à l'intérieur et au début du main, si bien que j'ai quelque chose qui ressemble à ça :
Code:

1 2 3 4 5 6 int main(void) { int fonction1(int,double); double fonction2(int,double); ....
Est ce bien correct ?
Oui, même si moi je préfère les déclarer en dehors de main. En les déclarant dans le corps de main, tu limites leur utilisation à main.
Citation:
Envoyé par kromartien
*J'écris les définitions de fonction après le main, si bien que j'ai quelque chose du genre :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 int main(void) { int carre(int,int); ... return 0; } int carre(int a, int b) { return a*b; }
Est ce bien correct ?
Exact! Une fonction ne peut être définie dans le corps d'une autre fonction. C'est le bon endroit pour définir carre. Tu peux également, suivant une approche plus modulaire, définir carre dans un autre fichier sources et lier les fichiers objet à l'édition des liens.
Citation:
Envoyé par kromartien
*Enfin, et je crois que c'est mon plus gros problème, j'ai du mal dans la manipulation des structures (passage par valeur, déclaration de nouvelles variable de type structure, ...)

La déclaration d'un nouveau type de structure par
Code:

1 2 3 4 5 6 7 struct ma_structure { int champ1; double champ2; ... };
1) est-elle correcte ?
2) Cela se fait-il dans le main (début) ou à l'extérieur du main (début ou fin ?), en particulier dans le cas de fonctions définies à l'extérieur du main manipulant des objets de type ma_structure ?
1) C'est correct!
2) Je le fait en général avant main. Tu trouveras plus d'infos sur la manière d'organiser tes développement à cette adresse: http://emmanuel-delahaye.developpez....ganiser_source
Citation:
Envoyé par kromartien
Pour terminer, j'aimerai savoir comment utiliser le nouveau type créé. Doit on écrire dans le cas de la création d'un nouvel objet de type ma_structure
Code:

1 2 struct ma_structure objet1;
ou bien
Code:

1 2 ma_structure objet1;
?
C'est la première version que tu dois utiliser, ou alors créer un alias de type avec la syntaxe suivante:
Code:

1 2 3 4 typedef struct ma_structure ma_structure; /*...*/ ma_structure objet1;
Citation:
Envoyé par kromartien
De même, lorsque ce type est manipulé par des fonctions, comment doit on écrire prototype et définition :

prototype ?
Code:

1 2 struct ma_structure une_fonction(struct ma_structure);
ou
Code:

1 2 ma_structure une_fonction(ma_structure);
Ni l'un ni l'autre! En général, on ne passe pas de structure par valeur à une fonction (idem pour la valeur de retour). On préfère passer un pointeur sur la structure en question en argument de la fonction:

Code:

void une_fonction(struct ma_structure *);
Citation:
Envoyé par kromartien
définition?
Code:

1 2 3 4 5 struct ma_structure une_fonction(struc ma_structure objet1) { ... }
ou
Code:

1 2 3 4 5 ma_structure une_fonction(ma_structure objet1) { ... }
En ce qui concerne la définition, on fait:
Code:

1 2 3 4 void une_fonction(struct ma_structure *p_objet) { p_objet->champ1 = 10; }
On peut également retourner l'adresse d'une structure allouée dynamiquement à l'intérieur de la fonction:
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 #include <stdio.h> #include <stdlib.h> struct ma_structure * une_fonction(void) { struct ma_structure *p_temp; p_temp = malloc(sizeof *p_temp); if (p_temp != NULL) { /*...*/ } return p_temp; /* Si p_temp vaut NULL, l'allocation a échoué*/ } int main(void) { struct ma_structure *p_obj = une_fonction(void) if (p_obj == NULL) { fprintf(stderr, "L'allocation dans une fonction a échoué"); exit(EXIT_FAILURE); } /*...*/ free(p_obj), p_obj = NULL; return EXIT_SUCCESS; }
Bonne chance

Thierry

16/01/2007, 18h37
diogene

mujigka A propos des prototypes :

Citation:

En les déclarant dans le corps de main, tu limites leur utilisation à main.

Je ne crois pas que leur visibilité soient limitée à la fonction (comme dans le cas de la définition d'un nouveau type) mais au fichier
16/01/2007, 18h46
Emmanuel Delahaye
Citation:
Envoyé par kromartien

*Dans le programme, j'écris les prototypes de fonction à l'intérieur et au début du main, si bien que j'ai quelque chose qui ressemble à ça :

Code:

1 2 3 4 5 6 int main(void) { int fonction1(int,double); double fonction2(int,double); ....

Est ce bien correct ?
Non.

Si les fonctions sont définies dans le même fichier source, place les avant leur utilisation, selon le principe de bon sens "définir avant d'utiliser"

Si elle sont définies dans un autre fichier source (compilation séparée) place le prototypes séparés dans un .h que tu inclues dans le source contenant la définition des fonctions (pour la cohérence) et dans chacun des sources qui utilise ces fonctions.

http://emmanuel-delahaye.developpez....ganiser_source
http://emmanuel-delahaye.developpez.....htm#organiser

Citation:

*J'écris les définitions de fonction après le main, si bien que j'ai quelque chose du genre :
Est ce bien correct ?

Non, voir ci-dessus.
Citation:
*Enfin, et je crois que c'est mon plus gros problème, j'ai du mal dans la manipulation des structures (passage par valeur, déclaration de nouvelles variable de type structure, ...)

La déclaration d'un nouveau type de structure par

Code:

1 2 3 4 5 6 7 struct ma_structure { int champ1; double champ2; ... };

1) est-elle correcte ?
2) Cela se fait-il dans le main (début) ou à l'extérieur du main (début ou fin ?), en particulier dans le cas de fonctions définies à l'extérieur du main manipulant des objets de type ma_structure ?
"définir avant d'utiliser". C'est le principe de base. Quand on ne peut pas, on fait des déclarations séparées.

Au fait, il ne s'agit pas d'une création de type (rien de tel en C), mais d'une définition de structure.
Citation:
Pour terminer, j'aimerai savoir comment utiliser le nouveau type créé. Doit on écrire dans le cas de la création d'un nouvel objet de type ma_structure

Code:

1 2 struct ma_structure objet1;

ou bien

Code:

1 2 ma_structure objet1;

?
#1
Citation:
De même, lorsque ce type est manipulé par des fonctions, comment doit on écrire prototype et définition :

prototype ?
définition ?

Code:

1 2 struct ma_structure une_fonction(struct ma_structure);

ou

Code:

1 2 ma_structure une_fonction(ma_structure);
Pareil. De plus, je recommande l'usage des pointeurs pour éviter les copies. Pour les cas de lecture seul, l'usage du qualificateur 'const' permet de protéger les données initiales.

Citation:

Envoyé par diogene

mujigka A propos des prototypes : Je ne crois pas que leur visibilité soient limitée à la fonction (comme dans le cas de la définition d'un nouveau type) mais au fichier

Hmmm, pas si sûr...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
 
int main(void)
{
    void afficheHello(void);
    void afficheBonjour(void);
    afficheHello();
    afficheBonjour();
    return 0;
}
 
void afficheHello(void)
{
    printf("Hello\n");
    afficheBonjour();
}
 
void afficheBonjour(void)
{
    printf("Bonjour\n");
}

Code:

1
2
3
4
5
6
7
8
9
10
11
Project   : Console application
Compiler  : GNU GCC Compiler (called directly)
Directory : E:\Tmp\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c: In function `afficheHello':
main.c:15: warning: implicit declaration of function `afficheBonjour'
Linking console executable: E:\Tmp\zzzz.exe
Process terminated with status 0 (0 minutes, 0 seconds)
0 errors, 1 warnings

16/01/2007, 18h50
Emmanuel Delahaye

Citation:

Envoyé par diogene

mujigka A propos des prototypes : Je ne crois pas que leur visibilité soient limitée à la fonction (comme dans le cas de la définition d'un nouveau type) mais au fichier

Si c'est dans la fonction, si, d'où l'absurdité de la chose.

de toutes façon, si on définit avant d'utiliser comme le recommande le Bon Sens, il n'y a pas à s'embêter avec les prototypes séparés, sauf pour les cas de récursion mutuels, qui n'est pas inutile de repérer clairement, sachant les troubles que ça peut entrainer...
16/01/2007, 19h57
Thierry Chappuis

Citation:

Envoyé par diogene

mujigka A propos des prototypes :
Je ne crois pas que leur visibilité soient limitée à la fonction (comme dans le cas de la définition d'un nouveau type) mais au fichier

Je crois que tu te trompes (non vérifié), mais je ne déclare jamais mes fonctions de cette manière. La notion de portée existe aussi pour les déclarations de fonctions.

Thierry
18/01/2007, 05h57
kromartien
Oui auparavant j'écrivais toujours les prototypes de fonction au début du main, ce qui empêche d'utiliser les fonctions définies dans le corps d'autre fonctions. Maintenant je vais écrire tous les prototypes à l'extérieur du main pour pouvoir à tout endroit du fichier accéder aux fonctions. Mais encore mieux, plutôt que d'être dans le cas "prototypes avant le main, définitions après", on peut écrire les définitions avant le main et se passer de tout prototype si j'ai bien compris.

Citation:

C'est possible avant ou après. Mais si les prototypes sont dans le main et les fonctions avant le main, les prototypes ne servent plus à rien. Avec les prototypes en tête de fichier, l'ordre des fonctions (y compris main) est indifférent.

Merci.
Petite question dans le cas d'une fonction récursive : ai je le droit d'écrire au début de mon fichier
Code:

1 2 3 4 5 6 7 8 9 long factorielle(long a) { if(a==0) { return 1; } return(a*factorielle(a-1) }
sans utiliser de prototype ? Je pense que oui.

En fait oui ça marche très bien. Merci beaucoup. Vous me parliez d'un livre que je ferai bien d'acheter. Le livre ANSI-C de Ritchie est il assez complet ? Que me conseillez vous ? Je compile sous Linux avec GCC, j'en voudrai un qui colle bien avec ça.
18/01/2007, 08h55
Emmanuel Delahaye
Citation:

Envoyé par kromartien

Oui auparavant j'écrivais toujours les prototypes de fonction au début du main,

Bien que techniquement possible, cette pratique fortement déconseillée. Le C est malheureusement bourré de 'features' pour rendre le code illisible, voire dangereux... Plus que jamais "C is a sharp tool". Il faut être très entrainé pour manier le C sans danger...

Citation:

ce qui empêche d'utiliser les fonctions définies dans le corps d'autre fonctions. Maintenant je vais écrire tous les prototypes à l'extérieur du main pour pouvoir à tout endroit du fichier accéder aux fonctions.

Inutile, sauf absolue nécessité qui révèle souvent un danger potentiel (appel récursif croisé : fa() appelle fb() qui appelle fa()... risque de boucle).

Citation:

Mais encore mieux, plutôt que d'être dans le cas "prototypes avant le main, définitions après", on peut écrire les définitions avant le main et se passer de tout prototype si j'ai bien compris.

Se passer de prototype séparé. Il est même recommandé de qualifier ces fonctions de static (portée limitée à l'unité de compilation courante), afin de bien séparer les fonctions 'privées' des fonctions publiques (points d'entrée).

A lire entièrement...

http://emmanuel-delahaye.developpez.com/codage.htm

Citation:

Petite question dans le cas d'une fonction récursive : ai je le droit d'écrire au début de mon fichier sans utiliser de prototype ? Je pense que oui.

Il faut savoir que quand tu définis une fonction, tu définis aussi une déclaration intégrée et, dans certaines conditions, un prototype intégré.

http://emmanuel-delahaye.developpez.....htm#prototype

Dans le cas que tu présentes :
Code:

1 2 3 4 5 6 7 8 9 long factorielle(long a) { if(a==0) { return 1; } return(a*factorielle(a-1) }
Code:

long factorielle(long a)

est précisément
- une déclaration integrée
- un prototype integré.

l'appel (ici, récursif) se fait donc selon les règles actuelle de la Bonne Programmation qui recommande fortement (c'est un euphémisme), l'usage des prototypes.

C'est pourquoi, le mécanisme simple qui consiste à définir avant d'utiliser, surtout si on utilise la forme 'prototypale de la définition, telle qu'elle existe depuis 1989, répond à cette exigence de qualité de production de code.

Citation:

En fait oui ça marche très bien. Merci beaucoup.

Le fait que "ça marche" ne prouve rien en C. Il faut d'abord que le code soit exempt de comportements indéfinis, ce qui, à première vue, semble être le cas ici (sauf que le cas du débordement de valeur n'est pas traité.).

Pour augmenter la plage de valeurs possibles, tu devrais utiliser unsigned long, voire unsigned long long (C99).

Citation:

Vous me parliez d'un livre que je ferai bien d'acheter. Le livre ANSI-C de Ritchie est il assez complet ?

C'est un excellent livre de référence. Comme cours, il est discutable. Certains l'aiment bien, d'autres non.

Citation:

Que me conseillez vous ?

Le Braquelaire est un excellent cours. (références sur mon site).

Citation:

Je compile sous Linux avec GCC, j'en voudrai un qui colle bien avec ça.

Le C, c'est le C. Peu importe l'environnement de développement.

La programmation sous unixoïde et l'usage des fonctions systèmes qui en découle, c'est une autre science. Ne pas mélanger.

http://emmanuel-delahaye.developpez....m#c_vs_systeme