Quel type de retour pour ces fonctions ?

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 :oops:. De plus sur ces deux fonctions, je me suis complètement emmêler les pinceaux. :aie: Ce serrais sympa d'avoir votre avis :mrgreen:.

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

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 ; }

---

Citation:

---

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

---

:weird: :weird: :weird:

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 ?

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

Le programme me retourne bien lundi. :D

fonctions :

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

#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;   }

---

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:

---

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:

---

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:

---

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:

---

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.

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.

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:

---

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é ...

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:

---

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 };

---

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

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 8O :

Code:

---

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:

---

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 ; }

---

C'est parfaitement normal NULL est une constante (macro) à n'utiliser que pour les pointeurs !

Si tu renvoies NULL là où tu dois renvoyer un int, tu ne renvoies pas un int : tu renvoies un pointeur.

As-tu bien compris ce qu'est un cast et ce que cela implique ?

Merci.

@Bktero Si je retourne un 0, je retourne un entier mais si je renvoi NULL, je retourne un pointeur vers une adresse invalide. Caster c'est une conversion forcé de type en type.

C'est ça. Alors pourquoi tenter de renvoyer NULL dans timeInt() ? :)

aie heureusement j'ai vite changé ça. timeInt renvoie un entier ou error défini à -1. :)