Assigner des valeurs à des float dans une structure

Version imprimable

Bonsoir !

Je suis étudiant et je travaille sur un projet, mais depuis quelque jours je fais face à un problème qui m'empêche de progresser.

J'essaye d'écrire un projet propre et structuré.
Pour ce faire j'écris des fonctions que j'intitule Get...() et Set...()
servant à appeler des paramètres d'une structure ou à assigner des valeurs à ces paramètres.

Depuis le début, ces fonctions marchaient bien; j'ai par exemple créé une structure T_HEURE avec pour paramètre int heure, int minute, int seconde.
L'affichage et l'assignation des valeurs marche nickel.

Mais je butte sur une structure "T_POSITION" qui prend en paramètre des float dûment nommé "latitude" et "longitude".
Et donc, là ou je bloque, c'est que je rédige mes fonctions Set et Get exactement de la même manière que pour les autres structures, pourtant la compilation me donne des chose aberrantes.

Par exemple, pour le code suivant dans le main.c :
Code:

1 2 3 4 5 T_COORDONNEE *MaCoordonnee = (T_COORDONNEE*)malloc(TAILLE_T_COORDONNEE); SetLatitude(MaCoordonnee,50.3); SetLongitude(MaCoordonnee,120.5); printf("%f\n",GetLatitude(MaCoordonnee)); printf("%f\n",GetLongitude(MaCoordonnee));
La console m'affiche :
Code:

1 2 120.5000 120.5000
au lieu de :
Code:

1 2 50.300000 120.500000
Soit deux fois la même chose, et croyez moi j'ai vérifié 50 fois de ne rien avoir inversé.
Ou si au lieu de la ligne 4 et 5 j'appelle une fonction void d'affichage

Code:

AfficherCoordonnee(MaCoordonnee);

qui est simplement constitué de deux printf, la encore je ne comprend plus rien à ce que m'affiche la console genre :
Code:

1 2 272008302207532160000000.000000 0.000000
Bref, pour expliquer le titre de mon topic,
je pense que le problème vient du type float, car c'est la seule différence que je retrouve avec mes précédentes structures.

Voila,
je vous remercie d'avance pour votre aide.
Si vous avez besoin de davantage de détail sur le code, faites le moi savoir.

03/01/2013, 20h00
Lintel-oo

Salut je pense pouvoir t'aider ;)

Pourrais tu seulement afficher le code des fonctions setLattitude/longitude et afficheCoordonnees ?

Voici :

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
 
#include <stdio.h>
#include "param.h"
 
 
//set
void SetLatitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude)
{ 
     CetteCoordonnee->latitude = CetteLatitude;
}
 
void SetLongitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLongitude)     
{ 
     CetteCoordonnee->longitude = CetteLongitude;
}
 
void SetCoordonnee(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude,const float CetteLongitude)
{
     SetLatitude(CetteCoordonnee,CetteLatitude);
     SetLongitude(CetteCoordonnee,CetteLongitude);
}
 
 
//get
float GetLatitude(const T_COORDONNEE *const CetteCoordonnee)
{
      return CetteCoordonnee->latitude;
}
 
float GetLongitude(const T_COORDONNEE *const CetteCoordonnee)
{
      return CetteCoordonnee->longitude;
}
 
 
//afficher
void AfficherCoordonnee(const T_COORDONNEE *const CetteCoordonnee)
{
     printf("La latitude est : %3.6f\n",GetLatitude(CetteCoordonnee));
     printf("La longitude est : %4.6f\n",GetLongitude(CetteCoordonnee));
}

En c++ ce code fonctionne comme attendu :

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
#include <stdio.h>
 
struct T_COORDONNEE
{
    float latitude;
    float longitude;
};
 
//set
void SetLatitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude)
{
     CetteCoordonnee->latitude = CetteLatitude;
}
 
void SetLongitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLongitude)
{
     CetteCoordonnee->longitude = CetteLongitude;
}
 
void SetCoordonnee(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude,const float CetteLongitude)
{
     SetLatitude(CetteCoordonnee,CetteLatitude);
     SetLongitude(CetteCoordonnee,CetteLongitude);
}
 
 
//get
float GetLatitude(const T_COORDONNEE *const CetteCoordonnee)
{
      return CetteCoordonnee->latitude;
}
 
float GetLongitude(const T_COORDONNEE *const CetteCoordonnee)
{
      return CetteCoordonnee->longitude;
}
 
 
//afficher
void AfficherCoordonnee(const T_COORDONNEE *const CetteCoordonnee)
{
     printf("La latitude est : %3.6f\n",GetLatitude(CetteCoordonnee));
     printf("La longitude est : %4.6f\n",GetLongitude(CetteCoordonnee));
}
 
 
 
 
int main()
{
    T_COORDONNEE *MaCoordonnee = new T_COORDONNEE();
    SetLatitude(MaCoordonnee,50.3);
    SetLongitude(MaCoordonnee,120.5);
    printf("%f\n",GetLatitude(MaCoordonnee));
    printf("%f\n",GetLongitude(MaCoordonnee));
 
    AfficherCoordonnee(MaCoordonnee);
 
    delete MaCoordonnee;
    return 0;
}

Pourrais-tu passer l'intégralité de ton code afin de voir ce qui cloche je pense au niveau de la gestion de la mémoire.

Edit : Et d'ailleurs en C ça fonctionne aussi ;) :

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
#include <stdio.h>
 
struct T_COORDONNEE
{
    float latitude;
    float longitude;
};
 
typedef struct T_COORDONNEE T_COORDONNEE;
 
//set
void SetLatitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude)
{
     CetteCoordonnee->latitude = CetteLatitude;
}
 
void SetLongitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLongitude)
{
     CetteCoordonnee->longitude = CetteLongitude;
}
 
void SetCoordonnee(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude,const float CetteLongitude)
{
     SetLatitude(CetteCoordonnee,CetteLatitude);
     SetLongitude(CetteCoordonnee,CetteLongitude);
}
 
 
//get
float GetLatitude(const T_COORDONNEE *const CetteCoordonnee)
{
      return CetteCoordonnee->latitude;
}
 
float GetLongitude(const T_COORDONNEE *const CetteCoordonnee)
{
      return CetteCoordonnee->longitude;
}
 
 
//afficher
void AfficherCoordonnee(const T_COORDONNEE *const CetteCoordonnee)
{
     printf("La latitude est : %3.6f\n",GetLatitude(CetteCoordonnee));
     printf("La longitude est : %4.6f\n",GetLongitude(CetteCoordonnee));
}
 
 
 
 
int main()
{
    T_COORDONNEE *MaCoordonnee = (T_COORDONNEE*)malloc(sizeof(T_COORDONNEE));
    SetLatitude(MaCoordonnee,50.3);
    SetLongitude(MaCoordonnee,120.5);
    printf("%f\n",GetLatitude(MaCoordonnee));
    printf("%f\n",GetLongitude(MaCoordonnee));
 
    AfficherCoordonnee(MaCoordonnee);
 
    free(MaCoordonnee);
    return 0;
}

A titre indicatif tu pourrais me donner la valeur de la constante de taille de la structure ? Si elle est différente de 8 ça pourrait expliquer ton problème !

L'intégralité ?
Oulala ça risque d'être un peu long, j'ai ajouté beaucoup de fichier dans le projet !
Bon, eh bien dans ce cas allons-y

Pour info, le but du projet est de guider un bateau vers les ports les plus proches en fonctions des marées, tout ça...

Et les seuls fichiers sources liés à la structure T_COORDONNEE sont coordonnee.h, coordonnee.c, main.c, param.h

main.c

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
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "param.h"
 
 
int main(int argc, char *argv[])
{
//base de donnees des differents ports
 
T_PORT *Dunkerque = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Brest = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Calais = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Boulogne_sur_Mer = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Concarneau = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Dieppe = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Fecamp = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Ile_de_Groix = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Le_Havre = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Port_Navalo = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Cherbourg = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Saint_Nazaire = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Saint_Malo = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Sable_d_olonne = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *La_Rochelle_Palisse = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Paimpol = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Pointe_de_Grave = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Roscoff = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Arcachon = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Boucau_Bayonne = (T_PORT *)malloc(  TAILLE_T_PORT );
T_PORT *Saint_Jean_de_Luz = (T_PORT *)malloc(  TAILLE_T_PORT );
 
Dunkerque->nom = "Dunkerque";
Brest->nom = "Brest";
Calais->nom = "Calais";
Boulogne_sur_Mer->nom = "Boulogne sur Mer";
Concarneau->nom = "Concarneau";
Dieppe->nom = "Dieppe";
Fecamp->nom = "Fecamp";
Ile_de_Groix->nom = "Ile de Groix";
Le_Havre->nom = "Le Havre";
Port_Navalo->nom = "Port Navalo";
Cherbourg->nom = "Cherbourg";
Saint_Nazaire->nom = "Saint-Nazaire";
Saint_Malo->nom = "Saint-Malo";
Sable_d_olonne->nom = "Les Sables d'Olonnes";
La_Rochelle_Palisse->nom = "La Rochelle Palisse";
Paimpol->nom = "Paimpol";
Roscoff->nom = "Roscoff";
Arcachon->nom = "Arcachon";
Boucau_Bayonne->nom = "Boucau-Bayonne/Biarritz";
Saint_Jean_de_Luz->nom = "Saint-Jean-de-Luz";
 
 
 
 
 
 
T_DATE *MaDate = (T_DATE *)malloc(  TAILLE_T_DATE ) ;
T_HEURE *MonHeure = (T_HEURE *)malloc(  TAILLE_T_HEURE );
 
 
 
SetDate(MaDate,21,12,2012);
AfficherDate(MaDate);
 
SetHEURE(MonHeure,16,30,0);
AfficherHEURE(MonHeure);
 
T_COORDONNEE *MaCoordonnee = (T_COORDONNEE *)malloc(TAILLE_T_COORDONNEE);
 
 
SetLatitude(MaCoordonnee,50.3);
SetLongitude(MaCoordonnee,120.5);
printf("%f\n",GetLatitude(MaCoordonnee));
printf("%f\n",GetLongitude(MaCoordonnee));
//SetCoordonnee(MaCoordonnee,55.6,62.5);  
AfficherCoordonnee(MaCoordonnee);
 
 
  system("PAUSE");	
  return 0;
}

param.h

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
#ifndef PARAM_H
#define PARAM_H
 
#define ANNEE_MIN 1800
#define ANNEE_MAX 2200
 
//rayon terrestre en km
#define R 6378
 
//Spirit of Australia 
#define VITESSE_BATEAU_MAX 511,13
 
// La latitude et la longitude se calcule a partir d'un angle en valeur decimale
// La longitude va de -180 a 180 a l'est ou a l'ouest
#define LONGITUDE_MAX 180.0
#define LONGITUDE_MIN -180.0
// La latitude va de -90 a 90 au nord ou au sud
#define LATITUDE_MAX 90.0
#define LATITUDE_MIN -90.0
 
 
#define MAREE_MAX 15
 
 
typedef struct S_COORDONNEE { float latitude;
                              float longitude; } T_COORDONNEE;
#define TAILLE_T_COORDONNEE sizeof(T_COORDONNEE)
 
 
//date
struct S_DATE { 
       int jour;
       int mois;
       int annee;
       };
 
typedef struct S_DATE T_DATE;
#define TAILLE_T_DATE sizeof( T_DATE )
 
 
//heure
struct S_HEURE {
       int heure;
       int minute;
       int seconde;
       };
 
typedef struct S_HEURE T_HEURE;
#define TAILLE_T_HEURE sizeof( T_HEURE )
 
 
 
//Bateau
struct S_BATEAU {
       T_COORDONNEE *coordonnee;
       float vitesse;
       };
 
typedef struct S_BATEAU T_BATEAU;
#define TAILLE_T_BATEAU sizeof ( T_BATEAU )
 
//Maree
//exprimee en metres
struct S_MAREE {
       float max;
       float min;
       float marnage;
       };
 
typedef struct S_MAREE T_MAREE;
#define TAILLE_T_MAREE sizeof ( T_MAREE )
 
//Port
struct S_PORT {
       T_COORDONNEE *coordonnee;
       T_MAREE *maree;
       char *nom;
       };
 
typedef struct S_PORT T_PORT;
#define TAILLE_T_PORT sizeof( T_PORT )
 
 
 
#endif

coordonnee.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#ifndef COORDONNEE_H
#define COORDONNEE_H
 
//set
void SetLatitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude);
 
void SetLongitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLongitude);
 
void SetCoordonnee(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude,const float CetteLongitude);
 
 
//get
float GetLatitude(const T_COORDONNEE *const CetteCoordonnee);
 
float GetLongitude(const T_COORDONNEE *const CetteCoordonnee);
 
//afficher
void AfficherCoordonnee(const T_COORDONNEE *const CetteCoordonnee);
 
 
#endif

coordonnee.c

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
#include <stdio.h>
#include "param.h"
 
 
//set
void SetLatitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude)
{ 
     CetteCoordonnee->latitude = CetteLatitude;
}
 
void SetLongitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLongitude)     
{ 
     CetteCoordonnee->longitude = CetteLongitude;
}
 
void SetCoordonnee(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude,const float CetteLongitude)
{
     SetLatitude(CetteCoordonnee,CetteLatitude);
     SetLongitude(CetteCoordonnee,CetteLongitude);
}
 
 
//get
float GetLatitude(const T_COORDONNEE *const CetteCoordonnee)
{
      return CetteCoordonnee->latitude;
}
 
float GetLongitude(const T_COORDONNEE *const CetteCoordonnee)
{
      return CetteCoordonnee->longitude;
}
 
 
//afficher
void AfficherCoordonnee(const T_COORDONNEE *const CetteCoordonnee)
{
     printf("La latitude est : %3.6f\n",GetLatitude(CetteCoordonnee));
     printf("La longitude est : %4.6f\n",GetLongitude(CetteCoordonnee));
}

date.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef BATEAU_H
#define BATEAU_H
#include "param.h"
 
 
//vitesse en km/h
void Set_Vitesse_Bateau(T_BATEAU *const CeBateau,const float CetteVitesse);
 
float Get_Vitesse_Bateau(T_BATEAU *const CeBateau);
 
 
 
#endif

date.c

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
#include <stdio.h>
#include "param.h"
#include "erreur_date.h"
 
 
//fonctions Set
void SetMois(T_DATE * const CetteDate, const int CeMois)
{
     CetteDate->mois = ( CeMois < 1 || CeMois > 12 ) ? ERREUR_MOIS : CeMois ;
}
 
void SetAnnee(T_DATE * const CetteDate, const int CetteAnnee)
{
     CetteDate->annee = ( CetteAnnee < ANNEE_MIN || CetteAnnee > ANNEE_MAX ) ? ERREUR_ANNEEE : CetteAnnee;
}
 
void SetDate(T_DATE *const CetteDate, const int CeJour, const int CeMois,const int CetteAnnee)
{
     SetMois(CetteDate,CeMois);
     SetAnnee(CetteDate,CetteAnnee);
     //mois de 31 jours
     if ((CetteDate->mois == 1) || (CetteDate->mois == 3) || (CetteDate->mois == 5) ||
         (CetteDate->mois == 7) || (CetteDate->mois == 8) || (CetteDate->mois == 10) ||
         (CetteDate->mois == 12))
         {
                          if(CeJour > 0 || CeJour <= 31)
                          {CetteDate->jour = CeJour;}
                          else 
                          {CetteDate->jour = ERREUR_JOUR;}                    
         }
 
 
     //mois de 30 jours    
     if ((CetteDate->mois == 4) || (CetteDate->mois == 6) ||
         (CetteDate->mois == 9) || (CetteDate->mois == 11))
         {
                          if(CeJour < 1 || CeJour > 30)
                          {CetteDate->jour = ERREUR_JOUR;}
                          else 
                          {CetteDate-> jour = CeJour;}
         }
 
     //mois de fevrier        
     if  (CetteDate->mois == 2)
         {
                          //test annee bissextile
                          if((CetteDate->annee %4 == 0 && CetteDate->annee %100 != 0) ||
                             (CetteDate->annee %400 == 0))
                             { 
                                               if(CeJour > 0 || CeJour <=29)
                                               {CetteDate->jour = CeJour;}
                                               else 
                                               {CetteDate->jour = ERREUR_JOUR;}
                             }
 
                          else {
                                               if(CeJour > 0 || CeJour <=28)
                                               {CetteDate->jour = CeJour;}
                                               else 
                                               {CetteDate->jour = ERREUR_JOUR;}
                               }
         }
}
 
 
 
 
//fonctions Get
int GetJour(const T_DATE * const CetteDate)
{
    return( CetteDate->jour) ;
}
 
int GetMois(const T_DATE * const CetteDate)
{
    return( CetteDate->mois) ;
}
 
int GetAnnee(const T_DATE * const CetteDate)
{
    return( CetteDate->annee) ;
}
 
//fonction affichage
void AfficherDate( const T_DATE * const CetteDate )
{ 
     printf("La date est le %d/%d/%d\n",GetJour(CetteDate),GetMois(CetteDate),GetAnnee(CetteDate));  
}

erreur_date.c

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#ifndef ERREURS_DATE_H
#define ERREURS_DATE_H
 
 
 
typedef enum { ERREUR_JOUR, ERREUR_MOIS, ERREUR_ANNEEE } T_CODE_ERREUR_DATE ;
 
 
static char *LibellesErreurs[] = {
 
       "Le jour est incorrect \n",
       "Le mois est incorrect \n",
       "L'annee est incorrecte \n",
 
};
 
#define NB_CODES_ERREURS_DATE sizeof(LibellesErreurs)/sizeof(LibellesErreurs[0])
 
 
 
#endif

heure.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#ifndef HEURE_H
#define HEURE_H
#include "param.h"
 
 
//methodes Set
void SetHEURE(T_HEURE *const CetteHeure, const int Cette_Heure,const int Cette_Minute,const int Cette_Seconde);
void SetHeure(T_HEURE *const CetteHeure, const int Cette_Heure);
void SetMinute(T_HEURE *const CetteHeure, const int Cette_Minute);
void SetSeconde(T_HEURE *const CetteHeure, const int Cette_Seconde);
 
//methodes Get
int GetHeure(const T_HEURE * const CetteHeure);
int GetMinute(const T_HEURE * const CetteHeure);
int GetSeconde(const T_HEURE * const CetteHeure);
 
//methode Afficher
void AfficherHEURE(const T_HEURE *const CetteHeure);
 
 
 
#endif

heure.c

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
#include <stdio.h>
#include "param.h"
#include "erreur_heure.h"
 
 
//fonctions Set
void SetHeure(T_HEURE *const CetteHeure, const int Cette_Heure)
{
     CetteHeure->heure = ( Cette_Heure < 0 || Cette_Heure > 23 ) ? ERREUR_HEURE : Cette_Heure ;
}
 
void SetMinute(T_HEURE *const CetteHeure, const int Cette_Minute)
{
     CetteHeure->minute = ( Cette_Minute < 0 || Cette_Minute > 59 ) ? ERREUR_MINUTE : Cette_Minute ;
}
 
void SetSeconde(T_HEURE *const CetteHeure, const int Cette_Seconde)
{
     CetteHeure->seconde = ( Cette_Seconde < 0 || Cette_Seconde > 59 ) ? ERREUR_SECONDE : Cette_Seconde ;
}
 
void SetHEURE(T_HEURE *const CetteHeure, const int Cette_Heure,const int Cette_Minute,const int Cette_Seconde)
{
     SetHeure(CetteHeure,Cette_Heure);
     SetMinute(CetteHeure,Cette_Minute);
     SetSeconde(CetteHeure,Cette_Seconde);
}
 
 
//fonctions Get
int GetHeure(const T_HEURE * const CetteHeure)
{
    return( CetteHeure->heure) ;
}
 
int GetMinute(const T_HEURE * const CetteHeure)
{
    return( CetteHeure->minute) ;
}
 
int GetSeconde(const T_HEURE * const CetteHeure)
{
    return( CetteHeure->seconde) ;
}
 
//methode Afficher
void AfficherHEURE(const T_HEURE *const CetteHeure)
{
     if(GetHeure(CetteHeure) < 10 && GetMinute(CetteHeure) > 9 && GetSeconde(CetteHeure) > 9)
     {
     printf("L'heure est 0%d:%d:%d\n",GetHeure(CetteHeure),GetMinute(CetteHeure),GetSeconde(CetteHeure));
     }
     else if(GetHeure(CetteHeure) > 9 && GetMinute(CetteHeure) < 10 && GetSeconde(CetteHeure) > 9)
     {
     printf("L'heure est %d:0%d:%d\n",GetHeure(CetteHeure),GetMinute(CetteHeure),GetSeconde(CetteHeure));
     }
     else if(GetHeure(CetteHeure) > 9 && GetMinute(CetteHeure) > 9 && GetSeconde(CetteHeure) < 10)
     {
     printf("L'heure est %d:%d:0%d\n",GetHeure(CetteHeure),GetMinute(CetteHeure),GetSeconde(CetteHeure));
     }
     else if(GetHeure(CetteHeure) > 9 && GetMinute(CetteHeure) < 10 && GetSeconde(CetteHeure) < 10)
     {
     printf("L'heure est %d:0%d:0%d\n",GetHeure(CetteHeure),GetMinute(CetteHeure),GetSeconde(CetteHeure));
     }
     else if(GetHeure(CetteHeure) < 10 && GetMinute(CetteHeure) > 9 && GetSeconde(CetteHeure) < 10)
     {
     printf("L'heure est 0%d:%d:0%d\n",GetHeure(CetteHeure),GetMinute(CetteHeure),GetSeconde(CetteHeure));
     }
     else if(GetHeure(CetteHeure) < 10 && GetMinute(CetteHeure) < 10 && GetSeconde(CetteHeure) < 10)
     {
     printf("L'heure est 0%d:0%d:0%d\n",GetHeure(CetteHeure),GetMinute(CetteHeure),GetSeconde(CetteHeure));
     }
     else if(GetHeure(CetteHeure) < 10 && GetMinute(CetteHeure) < 10 && GetSeconde(CetteHeure) > 9)
     {
     printf("L'heure est 0%d:0%d:%d\n",GetHeure(CetteHeure),GetMinute(CetteHeure),GetSeconde(CetteHeure));
     }
     else
     {
     printf("L'heure est %d:%d:%d\n",GetHeure(CetteHeure),GetMinute(CetteHeure),GetSeconde(CetteHeure));
     }
 
}

erreur_heure.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#ifndef ERREURS_HEURE_H
#define ERREURS_HEURE_H
 
 
 
typedef enum { ERREUR_HEURE, ERREUR_MINUTE, ERREUR_SECONDE } T_CODE_ERREUR_HEURE ;
 
 
static char *LibellesErreurs[] = {
 
       "L'heure est incorrecte \n",
       "La minute est incorrecte \n",
       "La seconde est incorrecte \n",
 
};
 
#define NB_CODES_ERREURS_HEURE sizeof(LibellesErreurs)/sizeof(LibellesErreurs[0])
 
 
#endif

utilitaire.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef UTILITAIRE_H
#define UTILITAIRE_H
#include "param.h"
 
 
 
 
//fonction qui calcule la distance entre le bateau et le port
 
double Distance_2_coordonnees(T_BATEAU *const CeBateau,T_PORT *const CePort);
 
float Temps_de_trajet(T_BATEAU *const CeBateau,const float CetteDistance);
 
float Marnage(T_MAREE *const CetteMaree);
 
 
 
#endif

utilitaire.c

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
#include <stdio.h>
#include <math.h>
#include "param.h"
 
//Fonction qui calcule la distance entre 2 coordonnees geographiques
double Distance_2_coordonnees(T_COORDONNEE *const coordonnee1,T_COORDONNEE *const coordonnee2)
{
 
 
      //conversion des degres en radian  (M_PI = pi dans math.h)
      double x1 = M_PI*GetLongitude(coordonnee1)/180;
      double x2 = M_PI*GetLongitude(coordonnee2)/180;
      double y1 = M_PI*GetLatitude(coordonnee1)/180;
      double y2 = M_PI*GetLatitude(coordonnee2)/180;
 
      //soit la formule permettant de calculer la distance entre 2 coordonnees geographiques
      //d = R * (Pi/2 - ArcSin( sin(destLat) * sin(sourceLat) + cos(destLong - sourceLong) * cos(destLat) * cos(sourceLat)))
 
      double distance = R*((M_PI/2) - asin(sin(y2)*sin(y1) + cos(x2-x1)*cos(y2)*cos(y1)));
 
      return distance;
}
 
//Fonction qui calcule le temps necessaire pour rejoindre un point de mouillage a partir d'une vitesse et d'une distance donnee
float Temps_de_trajet(T_BATEAU *const CeBateau,const double CetteDistance)
{
        return (CetteDistance/(Get_Vitesse_Bateau(CeBateau)));
}
 
//Fonction qui calcule le marnage
float Marnage(T_MAREE *const CetteMaree)
{
      return (Get_Max_Maree(CetteMaree) - Get_Min_Maree(CetteMaree));
}

maree.h

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
#ifndef MAREE_H
#define MAREE_H
#include "param.h"
 
//methodes Set
 
void Set_Min_Maree(T_MAREE *const CetteMaree,const float CeMin);
 
void Set_Max_Maree(T_MAREE *const CetteMaree,const float CeMax);
 
void SetMarnage(T_MAREE *const CetteMaree,const float CeMarnage);
 
//methode Get
 
float Get_Min_Maree(T_MAREE *const CetteMaree);
 
float Get_Max_Maree(T_MAREE *const CetteMaree);
 
float GetMarnage(T_MAREE *const CetteMaree);
 
 
 
 
#endif

maree.c

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
#include <stdio.h>
#include "param.h"
#include "erreur_maree.h"
 
//methodes Set
 
void Set_Min_Maree(T_MAREE *const CetteMaree,const float CeMin)
{
     CetteMaree->min = (CeMin < 0 ? ERREUR_MIN_MAREE : CeMin);
}
 
 
void Set_Max_Maree(T_MAREE *const CetteMaree,const float CeMax)
{
     CetteMaree->max = (CeMax > MAREE_MAX ? ERREUR_MAX_MAREE : CeMax);
}
 
 
void SetMarnage(T_MAREE *const CetteMaree,const float CeMarnage)
{
     CetteMaree->marnage = Marnage(CetteMaree);
}
 
 
//methodes Get
 
float Get_Min_Maree(T_MAREE *const CetteMaree)
{
      return (CetteMaree->min);
}
 
 
float Get_Max_Maree(T_MAREE *const CetteMaree)
{
      return (CetteMaree->max);
}
 
float GetMarnage(T_MAREE *const CetteMaree)
{
      return (CetteMaree->marnage);
}

erreur_maree.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#ifndef ERREURS_MAREE_H
#define ERREURS_MAREE_H
 
 
 
typedef enum { ERREUR_MIN_MAREE, ERREUR_MAX_MAREE} T_CODE_ERREUR_MAREE ;
 
 
static char *LibellesErreurs[] = {
 
       "La basse-maree est incorrecte \n",
       "La haute-maree est incorrecte \n",
 
};
 
#define NB_CODES_ERREURS_DATE sizeof(LibellesErreurs)/sizeof(LibellesErreurs[0])
 
 
 
#endif

bateau.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef BATEAU_H
#define BATEAU_H
#include "param.h"
 
 
//vitesse en km/h
void Set_Vitesse_Bateau(T_BATEAU *const CeBateau,const float CetteVitesse);
 
float Get_Vitesse_Bateau(T_BATEAU *const CeBateau);
 
 
 
#endif

bateau.c

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include "param.h"
#include "erreur_bateau.h"
 
 
 
void Set_Vitesse_Bateau(T_BATEAU *const CeBateau,const float CetteVitesse)
{
     CeBateau->vitesse = ( CetteVitesse <= 0 || CetteVitesse > VITESSE_BATEAU_MAX ) ? ERREUR_VITESSE : CetteVitesse ;
}
 
double Get_Vitesse_Bateau(T_BATEAU *const CeBateau)
{
      return (CeBateau->vitesse);
}

erreur_bateau.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#ifndef ERREURS_POSITION_H
#define ERREURS_POSITION_H
 
 
typedef enum { ERREUR_VITESSE  } T_CODE_ERREUR_BATEAU ;
 
 
static char *LibellesErreurs[] = {
 
       "La vitesse est incorrecte \n",
 
};
 
 
#define NB_CODES_ERREURS_POSITION sizeof(LibellesErreurs)/sizeof(LibellesErreurs[0])
 
 
 
#endif

Je crois qu'il y a tout.
Mais bon, il va de soit que certain truc ne sont pas complet comme bateau,port,maree...

Alors si je met un printf en fin de code comme ci-dessous :
Code:

1 2 3 4 5 6 7 8 SetLatitude(MaCoordonnee,50.3); SetLongitude(MaCoordonnee,120.5); printf("%f\n",GetLatitude(MaCoordonnee)); printf("%f\n",GetLongitude(MaCoordonnee)); //SetCoordonnee(MaCoordonnee,55.6,62.5); AfficherCoordonnee(MaCoordonnee); printf("%f\n",TAILLE_T_COORDONNEE);
La console m'affiche que TAILLE_T_COORDONNEE vaut 120.5 :?

03/01/2013, 21h50
Lintel-oo

Ah oui ça vient peut être de là alors.
Essaie de remplacer

Code:

T_COORDONNEE *MaCoordonnee = (T_COORDONNEE *)malloc(TAILLE_T_COORDONNEE);

par

Code:

T_COORDONNEE *MaCoordonnee = (T_COORDONNEE *)malloc(sizeof(T_COORDONNEE));

Ca devrait fonctionner ;)
03/01/2013, 21h53
Kai_Leng

J'ai essayé et malheureusement rien n'a changé :cry:

http://img4.imageshack.us/img4/3953/skipperconsole.png

Uploaded with ImageShack.us
03/01/2013, 22h19
Lintel-oo

Argh c'est bizarre tout cela ;)

Je vais essayer de télécharger ce que tu as fait pour voir ou ça cloche
03/01/2013, 22h24
Kai_Leng

Merci beaucoup de continuer à t'intéresser à mon cas.

Y'a-t-il moyen que je l'envoie sous forme d'archive ?
Cela serait plus rapide !

EDIT : http://www.packupload.com/PMJI2GTAYZ7
Si jamais.
03/01/2013, 22h38
Lintel-oo

Merci oui effectivement ça ira plus vite ;)

Il manque la définition de T_POSITION et le problème c'est que ça se retrouve à pas mal d'endroit elle est dans quel fichier normalement ?
03/01/2013, 22h44
diogene

Citation:

La console m'affiche que TAILLE_T_COORDONNEE vaut 120.5

TAILLE_T_COORDONNEE est un size_t, un entier, qui ne s'affiche pas avec un %f !
03/01/2013, 22h44
Kai_Leng

Ah, zut.
Avec quoi je l'affiche ?
Hexadécimal ?

Simplement avec %d au lieu de %f en tout cas la taille est bonne.

Essaie dans le main de remplacer

Code:

1
2
3
4
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "param.h"

Par :

Code:

1
2
3
4
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "coordonnee.h"

et dans "coordonnee.h" :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#ifndef COORDONNEE_H
#define COORDONNEE_H
 
#include "param.h"
//set
void SetLatitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude);
 
void SetLongitude(T_COORDONNEE *const CetteCoordonnee,const float CetteLongitude);
 
void SetCoordonnee(T_COORDONNEE *const CetteCoordonnee,const float CetteLatitude,const float CetteLongitude);
 
 
//get
float GetLatitude(const T_COORDONNEE *const CetteCoordonnee);
 
float GetLongitude(const T_COORDONNEE *const CetteCoordonnee);
 
//afficher
void AfficherCoordonnee(const T_COORDONNEE *const CetteCoordonnee);
 
 
#endif

03/01/2013, 22h51
Kai_Leng

Hum, oui en effet j'ai 8.
03/01/2013, 22h55
Lintel-oo

Ca devrait marcher maintenant si tu remplaces les includes comme je te l'ai indiqué
03/01/2013, 22h59
Kai_Leng

Oui ça marche !
Merci mille fois !

Mais alors, saurais-tu pourquoi T_HEURE et T_DATE fonctionne sans avoir inclus heure.h et date.h, et pas T_COORDONNEE ?
03/01/2013, 23h02
Lintel-oo

En fait je n'en sais rien :P ça m'est également arrivé mais je n'ai jamais compris l'ordre de compilation des fichiers, si ça se trouve c'est une simple histoire d'ordre alphabétique (il faudrait tester d'ailleurs ^^)

Il faudrait regarder du coté de "warning : impliciit declaration of"
03/01/2013, 23h12
Kai_Leng

C'est vrai que je ne vois vraiment pas pourquoi ça posait problème tant les résultat me semblait aberrants.
J'y réfléchirais une autre fois, j'ai bossé toute la journée déjà je vais me prendre une pause :lol:

En tout cas, merci encore et bonne soirée.
Je marque le sujet comme résolu !