Discussion :

[michel.semal]

Bonjour,

Je coince sur un probleme d'écriture.
J'ai ecris du code suivant ,
Main.c :

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
 
#include <....//mes include systeme
.....
typedef struct {
           tile_t date
           .........
          .......
} Mesures;
 
#include "....."//mes include locaux
 
int affOLED(Mesure *);
 
int main(int argc, char** argv) 
{
    ......//des definitions
   Mesures Mes;
.........  // du code
 
 
AffOled(&Mes);
 
.........//du code
 
 
}
 
int AffOled(Mesures *Mes)
{
	struct tm ld;
	ld= *localtime(&Mes->date);
 
     ......//du code
 
}

Cela fonctionne très bien.

Maintenant , comme le code de la fonction AffOLED() devient très important, je désire mettre cette fonction dans un fichier .c séparé.

J'ai donc écris un AffOLED.c ,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#.......//include systeme
#include "Affiche.h"
 
int AfficheOled(Mesures *Mes)
{
	char LaDate[50];
	struct tm *ld;
 
	ld= localtime(& (Mes->date));
.........................
 
}

Puis j'ai créé un .h comme suit :

Code :

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

1
2
3
4
5
6
7
8
9
 
#ifndef __AFFICHE
#define __AFFICHE
 
extern Mesures *;
 
extern int AfficheOled(Mesures *);
 
#endif

j'ai rajouter #include "Affiche.h" dans le main.c

Code :

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

1
2
3
4
5
6
7
8
9
10
 
typedef struct{
    } Mesures;
 
#include "Affiche.h"
 
int main(...)
{
....
}

Et la, plus rien ne vas......

J'ai essayer avec diverses versions du .h,
extern struct Mesures *Mes;
extern typedef Mesures *Mes;
extern typedef struct Mesures *Mes;



mais je crois surtout que je n'ai pas encore bien assimilé les pointeurs, les typedef, et autre subtilités du multi fichier en C
Si quelqu'un avait une idée, ou une correction.....
Pour info ce code est ecrit en C sous linux rasbian avec l'éditeur geany.
Un grand merci pour m'allumer la lumière

Michel

[Médinoc]

Le problème, c'est que tu n'as pas créé de type struct Mesures: Tu as seulement créé un type Mesures pour lequel tu ne peux pas utiliser de déclaration anticipée.
Ceci se corrige facilement:

Code :

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

1
2
3
4
5
6
7
8
//MonHeaderPartagé.h
 
struct Mesures;
typedef struct Mesures Mesures;
 
int AfficheOled(Mesures const*);
Mesures* Mesurer();
void DetruireMesures(Mesures*);

Code :

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

1
2
3
4
5
6
7
8
//MonImplémentation.h
#include <time.h>
 
struct Mesures {
           time_t date
           .........
          .......
};

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
//MonImplémentation.c
#include "MonHeaderPartagé.h"
#include "MonImplémentation.h"
 
int AfficheOled(Mesures const* Mes)
{
	char LaDate[50];
	struct tm *ld;
 
	ld= localtime(& (Mes->date));
	.........................
	return .....;
}
 
Mesures* Mesurer()
{
	Mesures* ret = malloc(sizeof *ret);
	if(ret != NULL) {
		.........
	}
	return ret;
}
 
void DetruireMesures(Mesures*p)
{
	free(p);
}

Le truc à garder à l'esprit, c'est que toutes les fonctions qui font directement appel au contenu de la structure Mesures (comme AfficheOled()) ont besoin d'avoir accès à sa définition complète.

[foetus]

extern Mesures *; -> ne sert à rien

extern int AfficheOled(Mesures *); -> une fonction/ procédure est toujours externe en C

Tu touches aux déclarations partielles

En gros, dans ton entête Affiche.h, le compilateur n'a pas besoin de la définition de ta structure puisque c'est un pointeur.
Par contre dans tes sources Affiche.c et main.c, il faut la définition : et donc un #include "one_mesure.h".

Le plus simple, c'est de mettre un #include "one_mesure.h" dans ton entête Affiche.h, et laisser le reste se faire naturellement


one_mesure.h :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef ONE_MESURE_H
#define ONE_MESURE_H
 
#include ... // <- comme time.h
 
 
typedef struct s_mesure {
    tile_t date
 
//  ...
} t_mesure;
 
 
#endif // ONE_MESURE_H

Édit : Attention au code de @Médinoc il a oublié les include guards (<- lien wiki en anglais)

[michel.semal]

Bonjour Medinoc et Foetus,

Merci pour les réponses rapides...

Si j'ai bien compris :

je cree un fichier .h qui contient les definitions de mes structures (et de mes variable globale ??)
Soit :

MesVariable.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#ifndef  __MESVAR
#define __MESVAR
#include <time.h>// pour l'utilisation du time_t
 struct Mesures
 {
     time_t date
     double mes1
........
} ;
 
double calcul  //autre variable globale
.......
#endif

Et ce fichier je l'inclus dans chaqu'un des .c ou .h où les variables/structure sont utilisée, comme variable ou comme pointeurs.
Pour ensuite dans les .c déclarer les variables/structure utilisée

AffOLED.h

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#ifndef  __AFFICHE
#define __AFFICHE
#include "MesVariable.h"
.........
typedef struct Mesures Mes;
 
int AffOLED(Mesure const*);
 
#endif

AffOLED.c

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#include <...>
#include "AfffOLED.h"
 
int AffOLED(Mesures const *Mes)
{
......   
  Mes->mes1++;
......
}

et pour finir , dans

main.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include<.....>
#include "MesVariables.h"
#include "AffOLED.h"
 
int main()
{
   Mesures MesNow;  
.............
 
   AffOLED(&MesNow);
.....
 
}

Est ce que là je m'approche ???

Pourquoi est ce que dan sla declaration de la fonction AffOLED (Mesures const *Mes) je dois mettre le pointeur sur la structure en const ???
cela n'aurais pas fonctionner avec ffOLED (Mesures *Mes) et evidemmentadapter la definition dans le AffOLED.h ?

Là je n'ai pas la possibilité de tester le code sinon cela serai fait avant de vous repondre.

Merci

Michel

[Sve@r]

Bonjour

je cree un fichier .h qui contient les definitions de mes structures (et de mes variable globale ??)
Est ce que là je m'approche ???

Oui c'est bon (enfin sauf pour l'utilisation de ces globales "de faignasse" "de confort")...

Pourquoi est ce que dan sla declaration de la fonction AffOLED (Mesures const *Mes) je dois mettre le pointeur sur la structure en const ???

C'est pour éviter de modifier accidentellement le pointeur. Evidemment ça fonctionne aussi sans ça.

[michel.semal]

Merci Sve@r.

Oui c'est bon (enfin sauf pour l'utilisation de ces globales "de faignasse" "de confort")...

Mais pourtant quand je lis des posts, je trouve que l'on parle partout qu'un bon devellopeur etait un fainéant.....

Pour les variables globales, c'est plus une question de rethorique que vraiment utilisé. Mais la remarque ci dessus reste valable

Pour la seconde remarque sur la defnition de la const*, je mettrais cela en pratique dès mon retour du taf;
A relire le post je me ppose encore des questions mais je verrai en essayant de comprendre.

Merci beaucoup à tous


Michel

[koala01]

Salut,

Mais pourtant quand je lis des posts, je trouve que l'on parle partout qu'un bon devellopeur etait un fainéant.....

C'est en effet ce qu'on lit souvent

On oublie juste de préciser qu'un bon développeur est un développeur fainéant ... qui sait quand ne pas l'être

Les variables globales créent souvent beaucoup plus de problème que ce qu'elle n'apportent de solution, ce qui nous donne une excellente raison de ne pas nous laisser aller à notre "fainéantise naturelle", car elle finira tôt ou tard par nous retomber dessus, et par nous occasionner beaucoup plus de travail que si nous avions décidé dés le départ de ne pas y souscrire

[foetus]

Est ce que là je m'approche ???

2-3 petites choses

Ton typedef tu peux directement le faire lors de la définition de ta structure, dans ton entête MesVariable.h. Regarde mon entête one_mesure.h.

Tu n'as pas besoin d'inclure MesVariable.h dans ton main.h, puisque l'entête AffOLED.h l'a déjà fait.

Je ne suis pas fan du fait de mélanger la structure avec les variables globales. Fait un fichier spécifique global.h, parce que sinon c'est le meilleur moyen de mettre des variables globales n'importe où. Et c'est d'ailleurs leur gros problème : tu ne pas contrôler à 100% leurs modifications si ton code devient important.


Après pour ne pas avoir de variables globales , je peux te parler d'injection de dépendance, d'interface, de singleton, ... mais bon cela sera pour plus tard vu que tu galères à faire 2 include et 1 structure.

[michel.semal]

bonjour à tous,

2-3 petites choses

Merci pour ces petites choses. C'est comme cela que je progresse le plus.

J'ai cherché sur internet et dans les forums, mais je n'ai rien trouver de clair sur les structure, pointeur, fonction et multifichier.
Sur chacun indépendament oui, parfois deux par deux mais pas sur les quatre ensemble.(ou du moins j'ai pas compris)

Donc, un fichier .h pour les defintion de structure (avec le typedef et sans les variable globales d'ailleur je n'en ai pas)
Inclure ce fichier la ou il est necessaire.
Dans la même idée, on pourrait cree un fichier include.h qui regrouperait tous les ' #include<>' ?
On inclurai ce fichier dans chaque .c.

Après pour ne pas avoir de variables globales , je peux te parler d'injection de dépendance, d'interface, de singleton, ...

Je vais me pencher sur la question........

Merci a tous pour votre aide.

Michel

[foetus]

Dans la même idée, on pourrait cree un fichier include.h qui regrouperait tous les ' #include<>' ?
On inclurai ce fichier dans chaque .c.

Ce que tu as du mal à comprendre, c'est qu'à chaque fois tu fais un #include, tu vas avoir une copie intégrale du fichier inclus (qui va remplacer la commande préprocesseur)
C'est pour cela que 1) tout le monde dit que c'est archaïque 2) il faut mettre les include guards pour ne pas avoir de définitions dupliquées

Tout cela pour te dire , qu'il faut faire le moins d'#include afin de gagner du temps à la compilation - mais cela tu vas vite le comprendre avec un projet assez important
Donc faire une entête de brutasse oui mais

D'ailleurs pour ta culture, faire une entête de brutasse cela s'appelle une entête précompilée (precompiled header, lien wiki en anglais) qui existe depuis 1998 dans Visual.
L'idée : on met dans une entête toutes les entêtes qui sont sensées ne presque jamais être modifiées, on compile le tout et ce fichier binaire est inclus lors de l'édition des liens : cela permet de gagner du temps de compilation.

[Sve@r]

Tu n'as pas besoin d'inclure MesVariable.h dans ton main.h, puisque l'entête AffOLED.h l'a déjà fait.

Ah, moi justement j'aurais dit le contraire. Je suis en effet partisan du "j'inclus ce dont j'ai besoin sans me préoccuper si un autre include ne le fait pas déjà". Et comme je suis protégé par les include guard...
Hypothèse: j'ai besoin de "trucA" et "trucB", j'inclus alors "includeA" et "includeB" (toi tu inclus juste "includeA" car tu sais qu'il inclus automatiquement "includeB"). Mais le jour où je n'ai plus besoin de "trucA", je supprime "includeA" et mon code continue à compiler vu que "includeB" est toujours là. Alors que chez-toi, en supprimant "includeA" ton code ne compile plus...

[edgarjacobs]

J'en fais autant. Je ne suis pas sensé savoir quel include fait quel include, qui lui-même fait des include, etc. Donc je mets en include dans un .c tout ce dont il a besoin pour compiler correctement.

[foetus]

@Sve@r tu as tout fait raison

C'est comme je te le disais il y a quelque temps en arrière : il faut compartimenter/ faire des interfaces.

Dans ce cas : les sources maStruct.h, AffOLED.h et AffOLED.c sont toutes liées. Et tu as le main.

Donc, pour moi c'est normal que maStruct.h, il n'y a que la source AffOLED.X qui s'en occupe. C'est la notion d'encapsulation de la POO (programmation orientée objet).

Le main n'a pas à se préoccuper à inclure les fonctions (AffOLED.h), la structure (maStruct.h) et "je-ne-sais-pas-quoi". Elle inclue seulement l'interface "AffOLED"

Parce qu'on peut te rétorquer le fait inverse : si pour un raison X, la source/ interface "AffOLED" n'a plu besoin de la structure, et bien tu vas avoir un include mort dans le main qui te bouffera du temps à la compilation.

Et pour cela, tu compileras toujours, mais si le temps de compilation de ton projet explose tu vas perdre du temps à trouver tous les include qui ne servent à rien

[michel.semal]

Bonjour

Le sujet est passionnant, je trouve que le débat est motivant.

Pour ajouter une (petite) pierre à l'edifice, je dirait ceci:

Le programme en question est desftiné a remplir la structure (les données).
Donc le main.c a besoins de le definition de la structure (MesVariable.h)
Pour obtenir ces données le main .c utilise d'autre fonctions (.c) qui elles retournes une valeur.
Le main.c depose les valeur de retour des fonction dans la structure

la affOLED.c elle affiche les données de la structure sur un display OLED.
Donc dette fonction a besoin de la definition de la structure(MesVariable.h)

En suivant ce qui c'est dit précedement, dans e cas d'espèce, Il vaut mieux faire un include de MesVaraible.h dans tous les .c qui auront besoins d'acceder a cette structure,
L'affichage vers un ecran
La mise en fichier des données,
La validation (mesures cohérente ou non)
......

Tandis que si la structure n'est utilisée que pour afficher les donnée (mais d'ou viennent-elles?) on n'en a besoisn que dans AffOLED.c.

Pour parler du projet, compiler l'executable sous linux fait 139K avec les bibliothèque pour l'OLED et WiringPi.
Donc la compilation lorsque tout vas bien (que j'ai retirer mes mouffles) ne met pas 1seconde. (en fait un peur plus longtemps lorsque je recompile la partie OLED.

@Sve@r tu as tout fait raison
Donc, pour moi c'est normal que maStruct.h, il n'y a que la source AffOLED.X qui s'en occupe.(programmation orientée objet).

Donc vu mon projet, et que d'autres fonctions que main et AffOLED ont besoin de cette structure, je la laisse aussi dans le main.c (et là ou elle sera utilisée)

Par contre la remarque est judicieuse pour d'autre cas.
n'étant pas programmeur professionnel, mes projet dépassent rarement le Mb compilés.
Donc je n'ai jamais rencontrer de projet qui mettent du temps à compiler....

C'est la notion d'encapsulation de la POO

Comme M Jourdain , "Je fais de la prose sans le savoir" Yes!! mais c'est un autre débat...


Je reste assidument à l’écoute de vos remarques, commentaires et enseignements.

Michel