Discussion :

[Magnum8760]

Bonjour, c'est dans le titre. Je sais qu'il faut mieux allouer dynamiquement (avec malloc()) le tableau et retourner son pointeur mais ayant définis mes constantes préalablement je ne sais pas comment m'y prendre . De plus sur ces deux fonctions, je me suis complètement emmêler les pinceaux. Ce serrais sympa d'avoir votre avis .

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
const char * NomJourSemaine[] = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};
 
const char * NomMois[] = {"janvier", "fevrier", "mars", "avril", "mai", "juin",
                          "juillet", "aout", "septembre", "octobre", "novembre", "decembre"};
 
 /**
 * Affiche la date et l'heure courante (format francais)
 * @param un pointeur vers une constante de char.
 * @return un pointeur vers une constante de type char.
 */
char *timeString (const char temps) {
      time_t timestamp ;
      struct tm * t ;
      timestamp = time(NULL) ;
      t = localtime(&timestamp) ;
      if(temps != 'J' && temps != 'M') {
          return EXIT_SUCCESS ;
      }
      if(temps == 'J')
          return (char*) NomJourSemaine[t->tm_wday] ;
      if(temps == 'M')
          return (char*) NomMois[t->tm_mon] ;
 }
  /**
  * Affiche la date et l'heure courante.
  * @param un pointeur vers une constante de char.
  * @return un entier naturel non signé (int).
  */
 size_t timeInt (const char temps) {
     time_t timestamp ;
     struct tm * t ;
     timestamp = time(NULL) ;
     t = localtime(&timestamp) ;
     switch (temps){
         case 'J' : return t->tm_wday ; break ;
         case 'M' : return t->tm_mon ; break ;
         case 'A' : return (1900 + t->tm_year) ; break ;
         case 'h' : return t->tm_hour ; break ;
         case 'm' : return t->tm_min ; break ;
         case 's' : return t->tm_sec ; break ;
     }
     //return EXIT_SUCCESS ;
 }

[Bktero]

Je sais qu'il faut mieux allouer dynamiquement (avec malloc()) le tableau et retourner son pointeur

Euh.... Non. Tu alloues dynamiquement quand tu ne connais pas la taille a priori ou quand la quantité de données est trop importante et risque des dépassement de pile.

Pour le reste.... Ton code est vraiment à revoir.

timeString dit dans sa documentation qu'elle affiche le temps mais elle n'affiche rien du tout, elle dit que son paramètre est un pointeur et c'est faux. Son nom est mauvais, on ne sait pas ce que fait la fonction. return EXIT_SUCCESS ? Mais pourquoi donc ? return (char*) NomJourSemaine[t->tm_wday] ; : tu castes un const char* en char* ? Mais pourquoi donc ? D'ailleurs pourquoi renvoyer un char* et non un const char* ?

timeInt , c'est un peu pareil... La documentation est fausse, le nom est mauvais. Le type de retour est size_t ? Mais pourquoi donc ? Un entier non signé, c'est unsigned int. size_t c'est particulier et ne devrait être utilisé que dans certains cas.

Que cherches-tu à faire ? C'est un exercice ? C'est du "vrai code" ? A quoi sert-il ?

[Magnum8760]

En fait je veux créer deux fonctions qui me renvoie ce dont j'ai besoin en terme de temps

Le programme me retourne bien lundi.

fonctions :

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
 #include <stdlib.h>
 #include <time.h>
 #include <stdio.h>
 
 #include "time.h"
 
const char * NomJourSemaine[] = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};
 
const char * NomMois[] = {"janvier", "fevrier", "mars", "avril", "mai", "juin",
                          "juillet", "aout", "septembre", "octobre", "novembre", "decembre"};
 
 /**
 * Affiche la date et l'heure courante (format francais en lettre)
 * @param un character (détermine si on retourne le jour ou mois en cours).
 * @return une constante, un pointeur vers une chaîne de characters.
 */
const char *timeString (char temps) {
      time_t timestamp ;
      struct tm * t ;
      timestamp = time(NULL) ;
      t = localtime(&timestamp) ;
      if(temps != 'J' && temps != 'M') {
          return EXIT_SUCCESS ;
      }
      if(temps == 'J')
          return NomJourSemaine[t->tm_wday] ;
      if(temps == 'M')
          return NomMois[t->tm_mon] ;
 }
  /**
  * Affiche la date et l'heure courante (au choix).
  * @param un character (détermine le retour).
  * @return un entier naturel non signé (int).
  */
 unsigned int timeInt (char temps) {
     time_t timestamp ;
     struct tm * t ;
     timestamp = time(NULL) ;
     t = localtime(&timestamp) ;
     switch (temps){
         case 'J' : return t->tm_wday ; break ;
         case 'M' : return t->tm_mon ; break ;
         case 'A' : return (1900 + t->tm_year) ; break ;
         case 'h' : return t->tm_hour ; break ;
         case 'm' : return t->tm_min ; break ;
         case 's' : return t->tm_sec ; break ;
     }
     return EXIT_SUCCESS ;
 }
 
 int main (void) {
     const char* x = timeString('J');
     printf("%s", x);
     return 0;
 
 }

[pjlan]

Bonjour, pour la fonction timeString tu devrais retourner un const char* tant qu'a faire cela t'éviterai de cast en char* derrière pour supprimer ton warning.
Sinon ton test

Code :

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

1
2
3
4
 
if(temps != 'J' && temps != 'M') {
     return EXIT_SUCCESS ;
}

devrait être fait en premier dans la fonction.
Mais surtout cela ne correspond pas à un cas de "succès" contrairement à ce que le suggére la constante "EXIT_SUCCESS".
D'ailleurs "EXIT_SUCCESS" est une constante entière donc ce n'est pas très correct le compilateur n'indique pas de warning ?
Ici le plus logique serait de retourner NULL (cas d'erreur).

Pour ta fonction timeInt tu devrais retourner un int car c'est le type qui correspond à la définition interne des champs de la struct tm.
Ensuite tu devrais avoir un

Code :

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

1
2
 
case default: return -1; // break; n'est pas nécessaire car l'instruction return interrompt le flux d'exécution.

Pour permetre le cas où l'utilisateur n'utilise pas une valeur appropriée.
-1 devrait éventuellement être un define pour eviter les valeurs magiques.
D'ailleurs ce serait peut être mieux d'utiliser des enum que des char en entrée (quoique en C la vérification sur les enum est minimale).

Enfin je pense que tu pourrais décomposer la première fonction en deux :

Code :

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

1
2
3
 
const char * quel_jour(const struct tm*);
const char* quel_mois(const struct tm*);

C'est plus flexible car tu peux aussi récupérer le jour et le mois d'une autre date.
et auquel cas tu peux écrire une fonction

Code :

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

1
2
 
struct tm* now()

si la struct tm ne te plait pas tu pourrais toujours gérer ta propre représentation d'une date avec une structure et définir des opérations sur cette structure.

[pjlan]

Bktero m'a devancé mais on ne doute pas que ça fonctionne (avec des warnings) mais pour autant il y a pas mal de point d'amélioration.

[Magnum8760]

Merci, grâce aux derniers conseils prodigués , je n'ai plus d'attentions. Il y a toujours moyen d'améliorer !

Ici je quitte si :

Code :

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

1
2
3
      if(temps != 'J' && temps != 'M') {
          exit(EXIT_FAILURE) ;
      }

return NULL; pour la fonction de type const char*.
default : return ERROR; (#define ERROR -1) pour la fonction de type entier non signé ...

[pjlan]

Utiliser la fonction exit() est excesif pour un cas comme ça. Tu devrais faire un return NULL; (par exemple)
timeInt devrait plutôt retourner un int tout court vu que dans la définition de la struct tm il s'agit bien d'int.

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
 struct tm {
  int tm_sec;           /* Seconds. [0-60]      */
  int tm_min;           /* Minutes. [0-59]      */
  int tm_hour;          /* Hours.   [0-23]      */
  int tm_mday;          /* Day.     [1-31]      */
  int tm_mon;           /* Month.   [0-11]      */
  int tm_year;          /* Year - 1900.         */
  int tm_wday;          /* Day of week. [0-6]   */
  int tm_yday;          /* Days in year.[0-365] */
  int tm_isdst;         /* DST.     [-1/0/1]    */
 
# ifdef __USE_BSD
  long int tm_gmtoff;       /* Seconds east of UTC.    */
  const char *tm_zone;      /* Timezone abbreviation.  */
# else
  long int __tm_gmtoff;     /* Seconds east of UTC.    */
  const char *__tm_zone;    /* Timezone abbreviation.  */
# endif
};

[Bousk]

Ce genre d'erreur devrait surtout être traité via un assert.

[Magnum8760]

Le retour -1 passe bien avec la fonction de type int et le retour NULL passe bien avec la fonction qui pointe vers une chaîne de caractères. Ce qui m'étonne c'est que le retour -1 passe aussi avec le type unsigned int !

Par contre (ça vaut ce que ça vaut !), j'ai regardé sur Wiki et ils définissent le NULL comme un cast de 0 : ((void*)0) ou ((char*)0). Par contre le plus étrange, c'est que cela ne fonctionne pas dans timeInt :

Code :

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

1
2
3
time.c: In function ‘timeInt’:
time.c:67:26: warning: return makes integer from pointer without a cast [-Wint-conversion]
          default: return NULL;

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
 
#define ERROR -1
 
const char *timeString(char temps) {
      if(temps != 'J' && temps != 'M') {
          return NULL ;
      }
      time_t timestamp ;
      struct tm * t ;
      timestamp = time(NULL) ;
      t = localtime(&timestamp) ;
      if(temps == 'J')
          return NomJourSemaine[t->tm_wday] ;
      if(temps == 'M')
          return NomMois[t->tm_mon] ;
      else
          return NULL ;
 }
 
int timeInt(char temps) {
     time_t timestamp ;
     struct tm * t ;
     timestamp = time(NULL) ;
     t = localtime(&timestamp) ;
     switch (temps){
         case 'J' : return t->tm_wday ;
         case 'M' : return t->tm_mon ;
         case 'A' : return (1900 + t->tm_year) ;
         case 'h' : return t->tm_hour ;
         case 'm' : return t->tm_min ;
         case 's' : return t->tm_sec ;
         default: return ERROR;
     }
     return ERROR ;
 }