IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

utilisation des fonctions mktime() et ctime()


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Profil pro
    Inscrit en
    Février 2006
    Messages
    24
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2006
    Messages : 24
    Par défaut utilisation des fonctions mktime() et ctime()
    Bonjour,
    Je cherche à lire une date depuis un fichier texte. Pour cela, j'ai utilisé la structure struct tm, qui me sert à convertir ma date en time_t par la fonction mktime.
    Jusqu'ici ça fonctionne, mais ensuite lorsque j'utilise ctime pour vérifier le résultat, le programme affiche (NULL) en lieu et place de la date.

    Je me suis inspiré d'un exemple (qui fonctionne) tiré d'ici

    Voici mon code source : (la fonction decoder() est de moi, tandis que fonction_test() est l'exemple que j'ai tiré du site ci dessus)

    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
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    #include <math.h>
    #include <stdio.h>
    #include <string.h>
    #include <time.h>
    #include <stdlib.h>
     
     
    int decoder(char* fichier, char* scolname, int marge, int deltaOnOff, int cptDebutAnalyse)
    {
     
    	FILE* fIN;
    	char ligne[256]; //les csv utilisés n'ont jamais de lignes de plus de 50 caractères.. alors 256 caractères offrent une bonne marge
    	int cpt=0,
    		nbCol=0,
    		colCible,
    		itok,
    		nbcarac,
    		nbLignes;
    	int* ievent;
    	char** token;
    	time_t tps;
    	char* tampon = (char*)malloc(100*sizeof(char));
    	unsigned int	*uidate,
    					*uipower;
    	struct tm date_struct;
    	// fread(void *buffer; size_t tailleBloc, size_t nombreBlocs, FILE *flot);
     
     
    	fIN = fopen(fichier, "r");
    	if(fIN == NULL)
    	{
    		return EXIT_FAILURE;
    	}
     
    	//lecture de la première ligne du fichier :
    	if(fgets(ligne, sizeof ligne, fIN)==NULL)
    	{//le fichier csv d'entrée est vide
    		return EXIT_FAILURE;
    	}
     
    	//parcours de la première ligne pour séparer les différents noms de colones (séparés par des ';' )
    	while(ligne[cpt]!='\0')
    	{
    		if(ligne[cpt]== ';')
    			nbCol++;
    		cpt++;
    	}
     
    	//réservation d'une zone mémoire pour garder les différents token (noms de colonnes)
    	token = (char**)malloc(nbCol*sizeof(char*));
    	if(token==NULL)
    		return EXIT_FAILURE;
     
    	//extraction des noms de colonnes
    	cpt = 0;
    	itok=0;
    	nbcarac=0;
    	while(ligne[cpt]!='\0')
    	{
    		if(ligne[cpt]==';')
    		{
    			tampon[nbcarac++]='\0';//ajouter le caractere \0 en fin de chaine dans tampon.
    			token[itok] = (char*)malloc(nbcarac*sizeof(char));
    			if(token[itok]==NULL)
    				return EXIT_FAILURE;
    			strcpy(token[itok++], tampon);
    			nbcarac = 0;
    			cpt++;
    		}
    		else
    		{
    			tampon[nbcarac++]=ligne[cpt++];
    		}
    	}
     
    	//recherche de la colonne à analyser (celle appelée scolname)
    	for(cpt=0; cpt<itok; cpt++)
    	{
    		if(strcmp(token[cpt], "scolname")==0)
    		{
    			colCible = cpt;
    			break;
    		}
    	}
     
    	/** A ce stade on sait que : Col 0 = date ; Col 1 = W ; Col 2 = interval ; Col colCible = courbe d'évenements **/
     
    	//mise en mémoire des données : Date, W, et courbe d'évenements
    	//parcourt du fichier entier pour savoir combien il y a de lignes (pour l'allocation mémoire)
    	nbLignes=0;
    	while(fgets(ligne, sizeof ligne, fIN)!=NULL)
    		nbLignes++;
     
    	//allocation mémoire pour les tableaux de données
    	uidate = (unsigned int*)malloc(nbLignes*sizeof(unsigned int));
    	uipower = (unsigned int*)malloc(nbLignes*sizeof(unsigned int));
    	ievent = (int*)malloc(nbLignes*sizeof(int));
     
    	fclose(fIN); //besoin de retourner au début du fichier. pas trouvé la fonction qui le fait, alors je ferme et je réouvre le fichier.
    	fIN = fopen(fichier, "r");
    	if(fIN == NULL)
    	{
    		return EXIT_FAILURE;
    	}
     
    	fgets(ligne, sizeof(ligne), fIN); //permet de sauter la première ligne, deja traitée
     
    	fgets(ligne, sizeof(ligne), fIN); //on traite la deuxième ligne à part, car c'est sur celle ci qu'on va lire et interpreter la date.
    	cpt = 0;
    	nbcarac = 0;
    	//lecture de l'année:
    	while(ligne[cpt]!='-')
    	{
    		tampon[nbcarac++]=ligne[cpt++];
    	}
    	tampon[nbcarac]='\0';
    	date_struct.tm_year = atoi(tampon)-1900;
     
    	cpt++;
    	nbcarac = 0;
     
    	//lecture du mois
    	while(ligne[cpt]!='-')
    	{
    		tampon[nbcarac++]=ligne[cpt++];
    	}
    	tampon[nbcarac]='\0';
    	date_struct.tm_mon = atoi(tampon)-1;
     
    	cpt++;
    	nbcarac = 0;
     
    	//lecture du jour
    	while(ligne[cpt]!=' ')
    	{
    		tampon[nbcarac++]=ligne[cpt++];
    	}
    	tampon[nbcarac]='\0';
    	date_struct.tm_mday = atoi(tampon);
     
    	cpt++;
    	nbcarac = 0;
     
    	//lecture de l'heure
    	while(ligne[cpt]!=':')
    	{
    		tampon[nbcarac++]=ligne[cpt++];
    	}
    	tampon[nbcarac]='\0';
    	date_struct.tm_hour = atoi(tampon);
     
    	cpt++;
    	nbcarac = 0;
     
    	//lecture des minutes
    	while(ligne[cpt]!=':')
    	{
    		tampon[nbcarac++]=ligne[cpt++];
    	}
    	tampon[nbcarac]='\0';
    	date_struct.tm_min = atoi(tampon);
     
    	cpt++;
    	nbcarac = 0;
     
    	//lecture des secondes
    	while(ligne[cpt]!=';')
    	{
    		tampon[nbcarac++]=ligne[cpt++];
    	}
    	tampon[nbcarac]='\0';
    	date_struct.tm_sec = atoi(tampon);
     
    	cpt++;
    	nbcarac = 0;
     
    	//conversion en time_t  
    	tps = mktime(&date_struct);
     
    	printf("temps lu : %d\nce qui correspond à la date du :\n%s\n", tps, ctime(&tps));
    	fclose(fIN);
     
    	return 0;
    }
     
    int fonction_test() {
        struct tm t;
        time_t tps;
        int jour, mois, an;
     
        printf("Jour : "); scanf("%d", &jour);
        printf("Mois : "); scanf("%d", &mois);
        printf("Annee: "); scanf("%d", &an);
     
        t.tm_year = an - 1900;
        t.tm_mon  = mois - 1;
        t.tm_mday = jour;
        t.tm_hour = t.tm_min  = t.tm_sec  = 0;
     
        tps = mktime(&t);
    	printf("\ntps = %d\n", tps);
        printf("Date et heure: %s\n", ctime(&tps));
        return 0;
    }
     
     
     
     
     
    int main()
    {
    	decoder("F:\\donnees R&D_tmp\\741-(cpt_elec)\\2005-09-02-R10000441-M00000741[N200].csv","W",30,20,200);
    	fonction_test();
    	return 0;
    }

    Et voici la trace de l'éxecution du programme :
    (lors de l'execution, j'ai entré la même date que celle figurant dans mon fichier texte. seule l'heure diffère de 4 secondes)

    temps lu : 1123106404
    ce qui corresponde à la date du :
    (null)
    Jour : 04
    Mois : 08
    Annee: 2005

    tps = 1123106400
    Date et heure : Thu Aug 04 00:00:00 2005

    Appuyez sur une touche pour continuer...
    Voila, si vous voyez ce qui cloche dans mon code, je vous serais reconnaissant de me le montrer

    Merci,

    Simon.

  2. #2
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par Xtatic
    Voila, si vous voyez ce qui cloche dans mon code, je vous serais reconnaissant de me le montrer
    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
     
    Project   : Forums
    Compiler  : GNU GCC Compiler (called directly)
    Directory : C:\dev\forums\
    --------------------------------------------------------------------------------
    Switching to target: default
    Compiling: main.c
    main.c: In function `decoder':
    main.c:180: warning: int format, time_t arg (arg 2)
    main.c: At top level:
    main.c:8: warning: unused parameter 'scolname'
    main.c:8: warning: unused parameter 'marge'
    main.c:8: warning: unused parameter 'deltaOnOff'
    main.c:8: warning: unused parameter 'cptDebutAnalyse'
    main.c: In function `decoder':
    main.c:81: warning: will never be executed
    main.c: At top level:
    main.c:186: warning: function declaration isn't a prototype
    main.c: In function `fonction_test':
    main.c:201: warning: int format, time_t arg (arg 2)
    main.c: At top level:
    main.c:211: warning: function declaration isn't a prototype
    main.c: In function `main':
    main.c:212: warning: passing arg 1 of `decoder' discards qualifiers from pointer target type
    main.c:212: warning: passing arg 2 of `decoder' discards qualifiers from pointer target type
    Linking console executable: console.exe
    Process terminated with status 0 (0 minutes, 3 seconds)
    0 errors, 11 warnings
    Peux-tu donner une exemple de ligne...

    Dans 'test', la structure doit être initialisée, sinon les autres champs on n'importe quelle valeur...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    int fonction_test (void)
    {
       struct tm t={0};
    <...>
    Ce qui donne :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    Jour : 1
    Mois : 1
    Annee: 2008
     
    tps = 1199142000
    Date et heure: Tue Jan 01 00:00:00 2008
     
     
    Press ENTER to continue.
    Ceci
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    if(strcmp(token[cpt], "scolname")==0)
    est douteux. C'est probablement
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    if(strcmp(token[cpt], scolname)==0)

  3. #3
    Membre averti
    Profil pro
    Inscrit en
    Février 2006
    Messages
    24
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2006
    Messages : 24
    Par défaut
    Bonjour,

    Merci pour la rapidité de réponse

    Voici les " premières lignes de mon fichier :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    DateTime;W;Interval;
    2005-08-04 00:00:04;0;41028.84
    2005-08-04 00:00:19;480;14.97
    Sachant que mon code cherche à lire la première date rencontrée.

    Je vais initialiser la structure dans la fonction 'fonction_test', ainsi que dans la fonction 'decoder' voir si ça améliore les choses.


    Résultat :
    J'ai initialisé la structure comme vous me l'avez montré,
    et j'obtiens le même résultat à un détail près : la valeur mesurée avance d'une heure. Voici la trace :

    temps lu : 1123110004
    ce qui correspond à la date du :
    (null)
    Jour : 04
    Mois : 08
    Annee : 2005

    tps : 1123110000
    Date et heure : Thu Aug 04 01:00:00 2005

    Appuyez sur une touche pour continuer...
    Pour préciser mon mode opératoire :
    La fonction 'decoder' doit lire mon fichier, et déchiffrer la date, et aux prompts de la fonction 'fonction_test', je donne la date correspondant à ce que devait lire la fonction 'decoder'.

    Element de réponse :
    L'heure étant fixée à 00:00:04 (resp. 00:00:00) pour la fonction 'decoder' (resp. 'fonction_test'), le fait d'obtenir pour les deux fonctions un résultat où l'heure est fixée une heure plus tard doit être du à l'option du changement horaire (été/hiver) de la structure 'struct tm' . Suffit de modifier l'initialisation du champs correspondant pour éviter ce problème.
    Mais il reste le problème de l'affichage de (null) au lieu de la date dans la fonction 'decoder'...

  4. #4
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par Xtatic
    Sachant que mon code cherche à lire la première date rencontrée.

    Mais il reste le problème de l'affichage de (null) au lieu de la date dans la fonction 'decoder'...
    Ceci fonctionne :
    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
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    #include <math.h>
    #include <stdio.h>
    #include <string.h>
    #include <time.h>
    #include <stdlib.h>
     
    int decoder (char const *fichier, char const *scolname, int marge,
                 int deltaOnOff, int cptDebutAnalyse)
    {
       int ret = EXIT_SUCCESS;
       FILE *fIN = fopen (fichier, "r");
       if (fIN != NULL)
       {
          char ligne[256];
     
    /* lecture de la première ligne du fichier : */
          if (fgets (ligne, sizeof ligne, fIN) != NULL)
          {
    /* parcours de la première ligne pour séparer les différents noms de colones (séparés par des ';' ) */
             int nbCol = 0;
     
             {
                int i = 0;
                while (ligne[i] != '\0')
                {
                   if (ligne[i] == ';')
                   {
                      nbCol++;
                   }
                   i++;
                }
             }
     
    /* réservation d'une zone mémoire pour garder les différents token (noms de colonnes) */
             {
                char **token = malloc (nbCol * sizeof (char *));
                if (token != NULL)
                {
    /* extraction des noms de colonnes */
     
                   int cpt = 0;
                   int itok = 0;
                   int nbcarac = 0;
                   char tampon[100];
     
                   while (ret == EXIT_SUCCESS && ligne[cpt] != '\0')
                   {
                      if (ligne[cpt] == ';')
                      {
    /* ajouter le caractere \0 en fin de chaine dans tampon. */
                         tampon[nbcarac] = '\0';
                         nbcarac++;
                         token[itok] = malloc (nbcarac);
                         if (token[itok] != NULL)
                         {
                            strcpy (token[itok], tampon);
                            itok++;
                            nbcarac = 0;
                            cpt++;
                         }
                         else
                         {
                            ret = EXIT_FAILURE;
                         }
                      }
                      else
                      {
                         tampon[nbcarac] = ligne[cpt];
                         nbcarac++;
                         cpt++;
                      }
                   }
     
    /* recherche de la colonne à analyser (celle appelée scolname) */
                   {
                      int i;
                      for (i = 0; i < itok; i++)
                      {
                         if (strcmp (token[i], scolname) == 0)
                         {
                            /* jamais utilise... */
                            int colCible = i;
                            break;
                         }
                      }
                   }
                }
                else
                {
                   ret = EXIT_FAILURE;
                }
    /** A ce stade on sait que : Col 0 = date ; Col 1 = W ; Col 2 = interval ; Col colCible = courbe d'évenements **/
     
    /* mise en mémoire des données : Date, W, et courbe d'évenements */
     
    /* parcourt du fichier entier pour savoir combien il y a de lignes (pour l'allocation mémoire) */
                {
                   struct tm date_struct = { 0 };
    /* besoin de retourner au début du fichier. pas trouvé la fonction qui le fait, alors je ferme et je réouvre le fichier. */
                   rewind (fIN);
     
    /* permet de sauter la première ligne, deja traitée */
                   fgets (ligne, sizeof (ligne), fIN);
     
    /* on traite la deuxième ligne à part, car c'est sur celle ci qu'on va lire et interpreter la date. */
                   fgets (ligne, sizeof (ligne), fIN);
                   {
                      int cpt = 0;
                      int nbcarac = 0;
                      char tampon[100];
    /* lecture de l'année: */
     
                      while (ligne[cpt] != '-')
                      {
                         tampon[nbcarac] = ligne[cpt];
                         nbcarac++;
                         cpt++;
                      }
                      tampon[nbcarac] = '\0';
                      date_struct.tm_year = atoi (tampon) - 1900;
     
                      cpt++;
                      nbcarac = 0;
     
    /* lecture du mois */
     
                      while (ligne[cpt] != '-')
                      {
                         tampon[nbcarac] = ligne[cpt];
                         nbcarac++;
                         cpt++;
                      }
                      tampon[nbcarac] = '\0';
                      date_struct.tm_mon = atoi (tampon) - 1;
     
                      cpt++;
                      nbcarac = 0;
     
    /* lecture du jour */
     
                      while (ligne[cpt] != ' ')
                      {
                         tampon[nbcarac] = ligne[cpt];
                         nbcarac++;
                         cpt++;
                      }
                      tampon[nbcarac] = '\0';
                      date_struct.tm_mday = atoi (tampon);
     
                      cpt++;
                      nbcarac = 0;
     
    /* lecture de l'heure */
     
                      while (ligne[cpt] != ':')
                      {
                         tampon[nbcarac] = ligne[cpt];
                         nbcarac++;
                         cpt++;
                      }
                      tampon[nbcarac] = '\0';
                      date_struct.tm_hour = atoi (tampon);
     
                      cpt++;
                      nbcarac = 0;
     
    /* lecture des minutes */
     
                      while (ligne[cpt] != ':')
                      {
                         tampon[nbcarac] = ligne[cpt];
                         nbcarac++;
                         cpt++;
                      }
                      tampon[nbcarac] = '\0';
                      date_struct.tm_min = atoi (tampon);
     
                      cpt++;
                      nbcarac = 0;
     
    /* lecture des secondes */
     
                      while (ligne[cpt] != ';')
                      {
                         tampon[nbcarac] = ligne[cpt];
                         nbcarac++;
                         cpt++;
                      }
                      tampon[nbcarac] = '\0';
                      date_struct.tm_sec = atoi (tampon);
     
                      cpt++;
                      nbcarac = 0;
                   }
    /* conversion en time_t */
                   {
                      time_t tps = mktime (&date_struct);
     
                      printf
                         ("temps lu : %ld\n"
                          "ce qui correspond a la date du :\n%s\n",
                          (long) tps, ctime (&tps));
                   }
                }
             }
          }
          else
    /* le fichier csv d'entrée est vide */
          {
     
             ret = EXIT_FAILURE;
          }
          fclose (fIN);
       }
       else
       {
          ret = EXIT_FAILURE;
       }
       return ret;
    }
     
    int fonction_test (void)
    {
       struct tm t = { 0 };
       time_t tps;
       int jour, mois, an;
     
       printf ("Jour : ");
       scanf ("%d", &jour);
       printf ("Mois : ");
       scanf ("%d", &mois);
       printf ("Annee: ");
       scanf ("%d", &an);
     
       t.tm_year = an - 1900;
       t.tm_mon = mois - 1;
       t.tm_mday = jour;
       t.tm_hour = t.tm_min = t.tm_sec = 0;
     
       tps = mktime (&t);
       printf ("\ntps = %ld\n", (long) tps);
       printf ("Date et heure: %s\n", ctime (&tps));
       return 0;
    }
     
    #if 0
    #define fname "F:\\donnees R&D_tmp\\741-(cpt_elec)\\" \
                  "2005-09-02-R10000441-M00000741[N200].csv"
    #else
    #define fname "data.txt"
    #endif
     
    int main (void)
    {
       decoder (fname, "W", 30, 20, 200);
       fonction_test ();
       return 0;
    }

  5. #5
    Membre averti
    Profil pro
    Inscrit en
    Février 2006
    Messages
    24
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2006
    Messages : 24
    Par défaut
    Merci,

    J'en suis à analyser ton code pour trouver d'où venait le problème.
    Je ne peux pas directement faire tourner ton code car mon compilateur n'apprécie pas les déclarations de variables qui suivent des instructions (ça pêche notamment à la déclaration des tableaux d'unsigned int.)

    Les différences que j'ai noté sont :
    -la gestion du retour en cas d'erreur;
    -le coup du "scolname" corrigé (j'ai repéré l'erreur juste après mon premier post, mais comme ça ne devait pas changer grand chose, j'ai préféré ne rien dire)
    -l'ajout d'accolades (je suppose que c'est pour permettre l'utilisation de variables temporaires qui disparaissent aussitôt l'accolade fermante franchie ?)

  6. #6
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par Xtatic
    Je ne peux pas directement faire tourner ton code car mon compilateur n'apprécie pas les déclarations de variables qui suivent des instructions (ça pêche notamment à la déclaration des tableaux d'unsigned int.)
    Corrigé (j'ai simplifié le code !)
    -l'ajout d'accolades (je suppose que c'est pour permettre l'utilisation de variables temporaires qui disparaissent aussitôt l'accolade fermante franchie ?)
    Oui, c'est le principe de la réduction de la portée des objets, ce qui rend le code plus lisible et surtout modulable.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [VB.NET][Excel] utiliser des fonction Excel comme xlToRight
    Par Alexj51 dans le forum Macros et VBA Excel
    Réponses: 5
    Dernier message: 01/03/2006, 12h10
  2. [Xml/XSl] utiliser des fonction vb
    Par ekmule dans le forum XSL/XSLT/XPATH
    Réponses: 6
    Dernier message: 17/01/2006, 17h28
  3. [hibernate] utilisation des fonctions d'aggregation
    Par osopardo dans le forum Hibernate
    Réponses: 2
    Dernier message: 29/08/2005, 09h41
  4. utilisation des fonctions d'une dll
    Par jackk dans le forum C++
    Réponses: 14
    Dernier message: 15/06/2005, 16h50
  5. Utiliser des fonctions Pascal
    Par Neilos dans le forum C++Builder
    Réponses: 2
    Dernier message: 07/03/2004, 15h43

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo