Discussion :

[insa59]

Salut a tous

Je voudrais que ma fonction retourner une chaine de caracteres mais cela n'est pas possible avec un return
Donc je voulais savoir comment on peut faire???

[Médinoc]

Il est possible de retourner une chaîne statique avec un bète return (genre return "abc"), mais c'est plus compliqué si la chaîne est créée dynamiquement.
Pour une chaîne créée, le mieux est d'utiliser l'allocation dynamique.

Exemple:

Code C non-testé :

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
#include <stdlib.h>
#include <stdio.h>
 
char const * RetourneChaineStatique(int a)
{
	if(a > 10)
		return "Plus que 10";
	else
		return "10 ou moins";
}
 
char * RetourneChaineDynamique(int a)
{
	/* Allocation dynamique : De la place pour 20 caractères */
	char * pRet = malloc(20*sizeof(*pRet));
	if(pRet != NULL)
	{
		sprintf(pRet, "a = %d", a);
	}
	return pRet;
}
 
int main(void)
{
	char * chnDyn = NULL;
 
	puts(RetourneChaineStatique(42));
 
	chnDyn = RetourneChaineDynamique(42);
	if(chnDyn != NULL)
	{
		puts(chnDyn);
		free(chnDyn); /* Le free() pourrait être hors du if, le standard dit que free(NULL) ne fait rien. */
	}
	return 0;
}

[Gruik]

2 autres methodes :

* Retourner un pointeur sur buffer statique / global-privé. Avantage : pas à se prendre la tete avec la libération. Inconvenient : les appels à la fonction ecrasent la valeur precedente. Utiliser le resultat directement

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
char * ret_chaine_static_buff(int a)
{
    static char buff[100];
    sprintf (buff, "Coucou %d", a);
    return buff;
}
 
static char private_buff[100];
char * ret_chaine_static_global_buff(int a)
{
    sprintf (private_buff, "Coucou %d", a);
    return private_buff;
}

* Laisser l'utilisateur de la fonction choisir où mettre la chaine. En general on donne la taille de la zone, pour eviter tout debordement. Ce genre de fonction peut aussi retourner un pointeur sur la zone passée (c'est ce que fait strcpy)

Code :

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

1
2
3
4
5
char * set_chaine (int param, const char * param2, char * zone, size_t zone_size)
{
   snprintf(zone, zone_size, "Coucou %d %s", param, param2);
   return zone;
}

[insa59]

Dsl main je ne comprends pas bien ton code c un peu compliqué
A part cette méthode il en n'existe pas d'autre un peu plus simple

merci

[Gruik]

Si : oublier les concepts de chaines des technologies comme Java, Php, VB... et raisonner avec des zones memoire

[insa59]

peux tu rentre plus ds le détail stp??

[insa59]

Je laisse mon petit bout de programme

le parametre int j permet de choisir la ligne à lire et à recuperer du fichier.txt
apres lecture la donnée et mise dans la chaine de caractere appeler chaine.
C'est cette variable chaine que je voudrais renvoyer

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
 
 
/*******************************************************************************
 
 *  Fonction  : lecture_fichier_txt
 
 *  Utilité   : Lecture des données du fichier.txt et modifictaion des paramètres 
 
                du récepteur MIMO via le programme init_attenuation
 
 *  Remarques : - Ici on utilise un buffer pour pouvoir lire la ligne du 
 
                  fichier.txt désiré.Cette ligne est modélisée par la variable j
 
                - Fonction qui ne récupére que les chaîne de caractères
 
                   du fichier    
 
********************************************************************************/
 
 
 
 
 
??? int lecture_fichier_txt(int j)
 
{
 
 FILE *fichier;
 
 int cpt = 0; // on initialise le compteur sur la premiere ligne
 
 char chaine[TAILLE_MAX]= ""; // On utilise une chaîne pour placer la data récuperer
 
 
 
 
 
 fichier = fopen("fichier_data.txt","r"); // Ouverture du fichier
 
 
 
  if (fichier != NULL) // Test d'ouverture
 
   {
 
   while (fgets(chaine, TAILLE_MAX, fichier) != NULL) // On fait une boucle while pour
 
    	 {                                       // chercher la ligne que l'on veut lire
 
 
 
          cpt=++cpt; // Attention ici on doit d'abord effectuer l'incrementation
 
           //printf("on va entrer ds la boucle if pour la %d fois\n",cpt);
 
           if(cpt==j) // Ici on choisit la ligne à récupérer     
 
             printf("la chaine de caractere est donc %d\n",Valeur);
 
 
 
 
 
         }
 
   }
 
 else
 
 printf("Impossible d'ouvrir le fichier fichier_data.txt");
 
 
 
??? return chaine;
  system("PAUSE"); 
 
}

Merci

[Gruik]

Et bien, une chaine en C, c'est juste le concept suivant : "une suite de caractere terminée par le caractère nul". Ce n'est pas une variable ou un objet comme dans les technologies citées plus haut.
Si tu veux manipuler des chaines comme dans ces technologies, il va falloir que tu sois aware d'une chose : les caractères qui les constituent sont forcément stoqués dans une zone memoire contigue. Obtenir une telle zone memoire est faisable de plusieurs façons et le plus simple est le tableau de caractere en variable locale (couramment appelé buffer)

Code :

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

1
2
3
4
5
6
7
 
int main(void)
{
  char mon_buffer[100];
  strcpy(mon_buffer, "Une chaine");
  return 0;
}

[Médinoc]

D'ici, je vois deux façons possibles:

1. La seconde que j'ai dite, avec l'allocation dynamique
   
   • Pour retourner une copie du buffer local (sauf qu'au lieu d'utiliser malloc() on peut utiliser strdup() pour aller plus vite)
   • Ou pour allouer directement le buffer local avec malloc(), puis le retourner.
2. La méthode proposée par Gruik:
   int lecture_fichier_txt(int j, char *buf, size_t taille_max)

[insa59]

dslé mais j'ai du mal je ne comprends pas les parametres que tu passe a la fonction peux tu me les expliquer

int lecture_fichier_txt(int j, char *buf, size_t taille_max)

car moi je n'ai besoin que d'un parametre le int j qui precise la ligne à récuperer ds le fichier

[insa59]

Une ptite explication???

[koala01]

dslé mais j'ai du mal je ne comprends pas les parametres que tu passe a la fonction peux tu me les expliquer
car moi je n'ai besoin que d'un parametre le int j qui precise la ligne à récuperer ds le fichier

Salut,

• int j, c'est le numéro de la ligne à récupérer
• char *buf, c'est la zone contigue en mémoire dans laquelle tu mettra ce que tu as lu
• size_t taille_max, c'est le nombre maximal de caractères que tu peux envisager de mettre dans buf...

Tout simplement (si du moins j'ai bien suivi le raisonnement de medinoc

Ces trois éléments doivent etre connus par la fonction, et il faut donc les passer en parametre...

Car, si tu ne les passe pas en parametre, la fonction n'aura aucun moyen de savoir où aller placer ce qu'elle lit dans le fichier, ni le nombre de caractères qu'elle peut se permettre d'y mettre

[Startux]

dans le paramètre il y a un un int j (je sais pa ce que c'est), un pointeur sur une chaine de caractères et un autre size_t taille_bidulechose

alors :
explication pour le pointeur => la fonction passe en paramètre un pointeur donc toutes les modifications que tu feras dans cette zone de mémoire restera quand tu sortiras de ta fonction (c'est équivalent à retourner une chaine de caractère)

explication pour le size_t taille_bidulechose => c'est pour que tu puisses allouer de la mémoire à ta chaine de caractères dans la fonction en fonction de tes besoins.

et le int j (je vois pas trop à quoi il sert)


Travailler, c'est avoir la santé, et surtout c'est LA GARDER !

[Médinoc]

Pour plus de détails sur l'usage de buf et taille_max, relis la seconde proposition de Gruik et applique-là à ton code.

[Thierry Chappuis]

dans le paramètre il y a un un int j (je sais pa ce que c'est), un pointeur sur une chaine de caractères et un autre size_t taille_bidulechose

alors :
explication pour le pointeur => la fonction passe en paramètre un pointeur donc toutes les modifications que tu feras dans cette zone de mémoire restera quand tu sortiras de ta fonction (c'est équivalent à retourner une chaine de caractère)

explication pour le size_t taille_bidulechose => c'est pour que tu puisses allouer de la mémoire à ta chaine de caractères dans la fonction en fonction de tes besoins.

et le int j (je vois pas trop à quoi il sert)


Travailler, c'est avoir la santé, et surtout c'est LA GARDER !

Là, je ne suis pas sûr que tu as compris! Une relecture du post de koala01, plus haut, s'impose...

Thierry

[insa59]

est -il possible d'avoir un réponse plus simple

a savoir quelle methode j'utilise et comment je dois la coder car la j'ai plusieurs réponse avec des uns qui disent que ces pas bon d'autre que c'est bon

je vous rappele ma fct si vous pouvez la changer pour que la fonction puisse recuperer la chaine svp car la je bloque vraiment

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
 
*******************************************************************************
 
 *  Fonction  : lecture_fichier_txt
 
 *  Utilité   : Lecture des données du fichier.txt et modifictaion des paramètres 
 
                du récepteur MIMO via le programme init_attenuation
 
 *  Remarques : - Ici on utilise un buffer pour pouvoir lire la ligne du 
 
                  fichier.txt désiré.Cette ligne est modélisée par la variable j
 
                - Fonction qui ne récupére que les chaîne de caractères
 
                   du fichier    
 
********************************************************************************/
 
 
 
 
 
??? int lecture_fichier_txt(int j)
 
{
 
 FILE *fichier;
 
 int cpt = 0; // on initialise le compteur sur la premiere ligne
 
 char chaine[TAILLE_MAX]= ""; // On utilise une chaîne pour placer la data récuperer
 
 
 
 
 
 fichier = fopen("fichier_data.txt","r"); // Ouverture du fichier
 
 
 
  if (fichier != NULL) // Test d'ouverture
 
   {
 
   while (fgets(chaine, TAILLE_MAX, fichier) != NULL) // On fait une boucle while pour
 
    	 {                                       // chercher la ligne que l'on veut lire
 
 
 
          cpt=++cpt; // Attention ici on doit d'abord effectuer l'incrementation
 
           //printf("on va entrer ds la boucle if pour la %d fois\n",cpt);
 
           if(cpt==j) // Ici on choisit la ligne à récupérer     
 
             printf("la chaine de caractere est donc %d\n",Valeur);
 
 
 
 
 
         }
 
   }
 
 else
 
 printf("Impossible d'ouvrir le fichier fichier_data.txt");
 
 
 
??? return chaine;
  system("PAUSE"); 
 
}

[Thierry Chappuis]

Les propositions de Médinoc et de Gruik sont toutes bonnes. Celle que j'utilise de préférence se rapproche de celle-là:

Code :

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

1
2
3
4
5
6
char * set_chaine (char *s_buffer, size_t buff_size, int param, const char * param2) 
{  
    snprintf(s_buffer, buff_size, "Coucou %d %s", param, param2); 
 
    return s_buffer; 
}

Thierry

[insa59]

j'ai compris thierry mais dslé je ne vois pas comment faire avec lma fonction car moi j'uitilise un fgets pour recuperer ma chaine et pour les parametres je mets koi??

Peux tu stp jeter un oeil a mon code ci dessus et me faire le changement adequat

Merci

[insa59]

une ptite réponse peut etre????

[souviron34]

on t'a déjà répondu....

En plus, on fera pas le boulot à ta place si tu fais pas plus d'efforts..

En particulier, relire les cours ou tutoriels ferait pas de mal :

http://nicolasj.developpez.com/articles/libc/string/

En enfin, on sait pas ce que tu veux faire exactement:

tu parles de ressortir une chaîne, mais tu lis tout le fichier....