Discussion :

[morpheus87]

Bonjour à tous,

j'ai un peu de mal à cerner la bonne solution et j'aimerai avoir votre avis.


J'ai donc 2 fichiers .c avec leurs .h respectif (main et fonction_vitesse)

Dans le fichier main.c, j'appelle "donneMoiLaVitesse()", cette fonction ne donne pas directement le resultat car elle passe par trois autres fonctions

=>miseEnForme qui prend 2 arguments
=>obtenirVitesseNonCorrige qui prend 3 trois arguments
=>ObtenirVitesseReel qui prend 2 arguments

Le squelette pour illustrer

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
//____________________________________________________________
main.c
------
int parm1, parm2, parm3, parm4, parm5;
 
while
{
  int result = donneMoiLaVitesse();
}
//_____________________________________
foction_vitesse.c
----------------
 
int donneMoiLaVitesse()
{
  int result1;
  int result2;
  int result3;
 
  result1 = miseEnForme(parm1, parm2);
  result2 = obtenirVitesseNonCorrige(result1 , parm3, parm4);
  result3 = ObtenirVitesseReel(result2 , parm5);
 
  return result3;
}
//_______________________________________________________________
 
}

Mon probleme proviens des variables globales (dans ce cas) parm1, parm2, parm3, parm4, parm5
Elles sont issues de main.c...
C'est pas tres modulaire tout çà

Attention, je refuse de passer 5 arguments à une fonction (trop difficile à debugger en test unitaire)

pour moi la seule solution, utiliser une structure externe pour récuperer les parametres

on aurait alors

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
//____________________________________________________________
main.c
------
 
int parm1, parm2, parm3, parm4, parm5;
void donneLesParametresAlaFonctionVitesse();
 
 
 
while()
{
  donneLesParametresAlaFonctionVitesse();
  int result = donneMoiLaVitesse();
}
 
 
 
void donneLesParametresAlaFonctionVitesse()
{
   ParamVitesse.parm1 = parm1;
   ParamVitesse.parm2 = parm2;
   ParamVitesse.parm3 = parm3;
   ParamVitesse.parm4 = parm4;
   ParamVitesse.parm5 = parm5;
}
 
//_____________________________________
fonction_vitesse.c
----------------
struct Param
{
  int parm1;
  int parm2;
  int parm3;
  int parm4;
  int parm5;
};
 
struct Param ParamVitesse;
 
int donneMoiLaVitesse()
{
  int result1;
  int result2;
  int result3;
 
  result1 = miseEnForme(ParamVitesse.parm1, ParamVitesse.parm2);
  result2 = obtenirVitesseNonCorrige(result1 , ParamVitesse.parm3, ParamVitesse.parm4);
  result3 = ObtenirVitesseReel(result2 , ParamVitesse.parm5);
 
  return result3;
}
//_______________________________________________________________
 
}

Mais je double l'espace memoire.

J'ai une autre solution, mais je préférerai l'éviter.(donc j'en parlerai plus tard)
Pouvez vous m'aider svp?

[diogene]

Pourquoi avoir ces variables globales ?
Logiquement, on devrait avoir un squelette du genre :

main.c

Code :

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

1
2
3
4
5
6
7
8
9
10
#include "vitesse.h"
int main(void)
{
  struct Param ParamVitesse;
  while()
  {
     ParamVitesse.parm1 = ... //est-il utile de passer par une variable supplémentaire parm1 ?
     int result = donneMoiLaVitesse(&ParamVitesse);
  }
  ....

vitesse.h

Code :

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

1
2
3
4
5
6
7
8
9
struct Param
{
  int parm1;
  int parm2;
  int parm3;
  int parm4;
  int parm5;
};
int donneMoiLaVitesse(struct Param * ParamVitesse);

vitesse.c

Code :

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

1
2
3
4
5
6
7
8
int donneMoiLaVitesse(struct Param * ParamVitesse)
{
  int result1;
  int result2;
  result1 = miseEnForme(ParamVitesse->parm1, ParamVitesse->parm2);
  result2 = obtenirVitesseNonCorrige(result1 , ParamVitesse->parm3, ParamVitesse->parm4);
  return ObtenirVitesseReel(result2 , ParamVitesse->parm5);
}

[morpheus87]

tres juste ta remarque et merci pour ta reponse.


je les avait mis en global car dans le main.c ils sont parametrable via RS232.

Mais ses paramètres sont là uniquement pour le fichier vitesse.c

donc ptit recap':

- param modifier (lecture/ecriture) dans le main via une com RS232
- utiliser dans vitesse.c

Est ce que cette solution est aussi bonne voir meilleur que celle que tu me proposes

mettre les parametres dans le fichier vitesse.c et si je veux les lire ou ecrire dans le main je passe par des fonctions dédiées dans vitesse.c?

[diogene]

Si tu ne les utilises que dans vitesse.c, tu n'as pas besoin de les faire connaitre au main.c et faire (mais je ne connais pas assez de ton projet pour faire une réponse catégorique) :

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
//---------------------------------
//main.c :
#include "vitesse.h"
int main(void)
{
  while()
  {
     int result = donneMoiLaVitesse();
  }
  ....
//---------------------------------
//vitesse.h
int donneMoiLaVitesse(void);
//---------------------------------
//vitesse.c :
struct Param
{
  int parm1;
  int parm2;
  int parm3;
  int parm4;
  int parm5;
};
static lireParam(struct Param  *ParamVitesse)
{
  // lecture des paramètres : ParamVitesse->parm1 =....
}
int donneMoiLaVitesse(void)
{
  int result1;
  int result2;
  struct Param  ParamVitesse;
  lireParam(&paramVitesse);
  result1 = miseEnForme(ParamVitesse.parm1, ParamVitesse.parm2);
  result2 = obtenirVitesseNonCorrige(result1 , ParamVitesse.parm3, ParamVitesse.parm4);
  return ObtenirVitesseReel(result2 , ParamVitesse.parm5);
}

[morpheus87]

merci pour ta reponse.

les parametres sont aussi utiliser dans main.c pour lecture/ecriture via RS232

En gros les parametres sont utiles uniquement dans vitesse.c, mais ils sont consultable via l'exterieur (ecriture et lecture)

Apres tes conseils, je me demande si:

- creer la variable struct param dans le main est l'envoyer via une fonction à vitesse.c (ta solution proposé)
ainsi si je veux les lire ou les parametrer dans le main il n'y a pas de probleme.

- Ou sinon creer la variable struct param dans le vitesse.c est les rendre accessible via une fonction lecture ou ecriture (integrer dans vitesse.c)
ainsi si je veux les lire ou les parametrer dans le main j'appelle la fonction appropriée.

Quand penses-tu?

[diogene]

Probablement, je ferais un mixage des deux solutions :

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
//---------------------------------
//main.c :
#include "vitesse.h"
int main(void)
{
  Param  ParamVitesse;
  while()
  {
     lireParam(&paramVitesse);     
     int result = donneMoiLaVitesse(&ParamVitesse);
     ....
     ecrireParam(&paramVitesse);
     ....
  }
  ....
}
//---------------------------------
//vitesse.h
typedef struct Param Param;
void lireParam(Param  *ParamVitesse);
void ecrireParam(Param const *ParamVitesse);
int donneMoiLaVitesse(Param const *ParamVitesse);
 
//---------------------------------
//vitesse.c :
#include "vitesse.h"
struct Param
{
  int parm1;
  int parm2;
  int parm3;
  int parm4;
  int parm5;
};
void lireParam(Param  *ParamVitesse)
{
  // lecture des paramètres : ParamVitesse->parm1 =....
}
void ecrireParam(Param const *ParamVitesse)
{
  // écriture des paramètres : ... = ParamVitesse->parm1 
}
int donneMoiLaVitesse(Param const * ParamVitesse)
{
  int result1;
  int result2;
  result1 = miseEnForme(ParamVitesse->parm1, ParamVitesse->parm2);
  result2 = obtenirVitesseNonCorrige(result1 , ParamVitesse->parm3, ParamVitesse->parm4);
  return ObtenirVitesseReel(result2 , ParamVitesse->parm5);
}

Dans cette formule, main.c ne connait plus la composition d'un Param (type opaque). Donc, toutes les fonctions manipulant le contenu d'un Param se trouveront définies dans vitesse.c et déclarée éventuellement dans vitesse.h (ou déclarée static dans vitesse.c).
Cela force le découplage du code entre la gestion fine des paramètres (dans vitesse.c) et leur utilisation à un niveau plus abstrait (dans les autres fichiers sources).