Discussion :

[Invité]

Bonjour,

je souhaite faire une fonction qui retourne un char * sans directement déclarer un char avant utilisation:

voici mon code actuel:

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
struct tm * DateAndTime(void)
{  
    time_t timer1;
    struct tm *newTime1;
 
    time(&timer1);
    newTime1 = localtime(&timer1);
    newTime1->tm_mon = newTime1->tm_mon + 1; 
    newTime1->tm_year = newTime1->tm_year + 1900;
 
    return newTime1;
}
 
T_CHAR * StringDateAndTime(T_CHAR * TimeString)
{
    struct tm *Time;
    Time = DateAndTime();
    sprintf(TimeString, "[%.2d:%.2d:%.2d]", Time->tm_hour, Time->tm_min, Time->tm_sec);
    return TimeString;
}

et je l'appel comme ceci

Code :

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

1
2
3
T_CHAR Time[MAX_DATE_LENTGH];
 
printf("%s bla bla\n", StringDateAndTime(Time));

cependant je souhaiterai directement avoir ça dans l'appel (sans la déclaration du Time...), possible ?

Code :

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

printf("%s bla bla\n", StringDateAndTime());

[TheGzD]

Tu pourrais passer par une variable globale, mais ce n'est pas très jolie vu le contexte.

[Obsidian]

Tu as plusieurs choix :

— Soit tu alloues de la mémoire à l'intérieur de ta fonction avec malloc(), tu remplis cet espace avec ton sprintf() et tu retournes le pointeur, en laissant à l'appelant la charge de faire free() dessus. Beaucoup de fonctions système font de même
— Soit tu fais exactement la même chose que localtime(), tu déclares un buffer « static » au sein de ta fonction (plutôt qu'utiliser une vraie globale), et tu retournes le pointeur sur ce buffer, qui ne disparaîtra jamais.

Inconvénients de cette seconde solution : 1) la mémoire n'est jamais libérée (même si elle reste minime et de taille fixe) ; 2) Elle n'est pas ré-entrante 3) Conséquence du second point : elle n'est absolument pas thread-safe.

À toi de voir.

[Invité]

Je me doutai un peu de ces deux réponses ... j’espérai une solution magique

Merci pour vos réponses

[Obsidian]

En fait, tu peux gagner localement en simplicité, si tu acceptes de compliquer le système autre part.

Le fait de ne pas disposer de type « string » en C n'est pas une limitation ou un oubli, c'est en fait que tu évolues « en dessous » de la couche objet gérée de façon transparente par d'autres langages. Il y a une voie que tu peux explorer : celle du garbage collector. L'idée est d'allouer de la mémoire à la volée, de la laisser vivre et de tout désallouer à intervalle régulier quand le moment est le bon.

Tu peux par exemple réécrire ta propre fonction my_malloc() qui alloue de la mémoire avec un malloc() ordinaire et renvoie un pointeur sur cet espace mais qui, en plus, tient de manière privée un registre de tous les segments qu'elle a alloués. La seule chose dont tu as besoin pour faire cela est un pointeur static, vers une zone de mémoire allouée par malloc() elle-aussi mais gérée exclusivement par ta fonction.

Si tu fais un usage raisonnable de ta fonction d'allocation, tu peux allouer n segments de mémoire de façon transparente sans les libérer, puis ensuite envoyer un signal spécial à ton fonction (par exemple avec un my_malloc(-1) ou quelque chose de similaire) pour lui dire qu'à ce stade, on est sûr que l'on n'aura plus jamais besoin de ce qui a été alloué, par exemple en quittant la fonction appelante, et lui demander de nettoyer d'un coup et de façon complètement transparente tout ce qui a été réservé durant la procédure.

[uknow]

Bonjour,

Je me doutai un peu de ces deux réponses ... j’espérai une solution magique

En plus des solutions citées ci-dessus il en reste une qui, bien entendu, manque d'élégance par rapport à une allocation dynamique.

La solution consiste à retourner une structure.
Plus la chaîne est longue, plus la différence de performance avec un retour de pointeur se verra :

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
#include <stdio.h>
#include <string.h>
 
typedef struct 
{
       char str[TAILLE];
 
} String ;
 
String foo( void )
{
       String s;
       strcpy( s.str , "Hello world" );
 
       return s;
}
 
int main( void )
{
      String s = foo();
 
      printf("%s\n", s.str );
 
      return 0;
}

[mohamine1989]

D'apres ce que j'ai pu comprendre, tu veut detecter l'heure locale de ton ordi, et le convertir en serie d'entiers
Pour retourner une valeur, il faut avoir une variable, ou une constante déclarée a l'interieur de la fonction, ou bien un champ d'une structure que la fonction peut y accecedée, sinon, pour ton programme, tu peut mettre

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
 
T_CHAR *TimeString;
struct tm *Time;
struct tm * DateAndTime(void)
{  
    time_t timer1;
    struct tm *newTime1;
 
    time(&timer1);
    newTime1 = localtime(&timer1);
    newTime1->tm_mon = newTime1->tm_mon + 1; 
    newTime1->tm_year = newTime1->tm_year + 1900;
 
    return newTime1;
} 
void StringDateAndTime ()
{
    Time = DateAndTime();
    sprintf(TimeString, "[%.2d:%.2d:%.2d]", Time->tm_hour, Time->tm_min, Time->tm_sec);
}

c-a-dire comme variable globale, tu vas gagner de la memoire a l'interieur de la fonction, c-a-dire, au moment de l'execution de la fonction
sinon, a la place de new, tu peut utiliser la fonction predefinit du language c "malloc" comme suite:

Code :

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

1
2
3
 
type_variable *variable;
variable = (type_variable *) malloc ((nbr_de_valeur_pointer) * sizeof (type_variable));

tu peut donc l'utiliser comme suite:

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
 
struct tm * DateAndTime(void)
{  
    time_t timer1;
    struct tm *newTime1 = (struct tm *) malloc (sizeof (struct tm));
    time(&timer1);
    newTime1 = localtime(&timer1);
    newTime1->tm_mon = newTime1->tm_mon + 1; 
    newTime1->tm_year = newTime1->tm_year + 1900;
 
    return newTime1;
} 
void StringDateAndTime (T_CHAR *TimeString)
{
    struct tm *Time;
    Time = DateAndTime();
    sprintf(TimeString, "[%.2d:%.2d:%.2d]", Time->tm_hour, Time->tm_min, Time->tm_sec);
}

mais ca revient au même