Discussion :

[pc2-bresil]

saluts,

nous sommes débutants en langage C.
nous avons le programme suivant:

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
 
#include <stdio.h>
#include <string.h>
 
char *cavaco (char *x)
{
	for (int a = 0; a < strlen(x); a++) {
		char *pars1 = (char *)malloc(a * sizeof(char));
		char *pars2 = (char *)malloc((strlen(x) - a) * sizeof(char));
		strncpy(pars1, x, a+1);
		pars1[a+1] = '\0';
		sprintf(pars2, "%s", &x[a+1]);
		printf("%s %s\n", pars1, pars2);
		free(pars1);
		free(pars2);
	}
}
int main(int argc, char *argv[])
{
    cavaco("cheval");
    return 0;
}

c'est très simple. la fonction "cavaco" retourne toutes les possibles divisions d'un mot, comme "cheval", en deux parties:

Code :

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

1
2
3
4
5
6
7
 
c heval
ch eval
che val
chev al
cheva l
cheval

la doute est: comment est-ce que nous pouvons faire la fonction retourner un array de strings - array de array de chars (char**) avec ces valeurs?
par exemple:

Code :

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

1
2
3
4
 
{"c heval",
"ch eval",
...}

et, donc, utiliser le valeur revenue?
s'il vous plaît, souvenez-vous que la taille de chaque string dans l'array ne serait pas toujours strlen(x) + 1 (dans le cas de "cheval", ça serait 7, à cause du " " -> "c heval", "ch eval", ...), parce que nous pouvons vouloir changer la fonction "cavaco" pour diviser le mot de plus de façons différents, par exemple "che eval" (donc, il peut être plus divisions possibles, ça dépend des critères de division que nous pouvons vouloir utiliser).

merci d'avance.

[Pierre Maurette]

Bonjour,

Je n'ai pas regardé attentivement votre code, mais je peux quand même vous faire une suggestion.
Vous déclarez une structure contenant un int N et un char** mots qui sera compris comme un tableau de N char*.
Votre fonction renvoie cette structure, et vous écrivez dans sa documentation que c'est l'appelant qui doit libérer. En fait, vous écrivez une fonction:
void free_cavaco(struct machin)
et vous marquez dans la documentation de caveco() que l'appelant devra appeler free_caveco() avec la structure renvoyée par caveco().
Vous accédez aux mots par struct.mots[n], et pour libérer vous faites free() sur chaque élément (char*) de mots puis sur mots.
Notez que accès et libération sont liés à des pointeurs qui peuvent être vus comme des clés suffisantes et nécessaires, il ne faut donc pas faire de free() dans la fonction cavaco().

[pc2-bresil]

Bonjour,

Je n'ai pas regardé attentivement votre code, mais je peux quand même vous faire une suggestion.
Vous déclarez une structure contenant un int N et un char** mots qui sera compris comme un tableau de N char*.
Votre fonction renvoie cette structure, et vous écrivez dans sa documentation que c'est l'appelant qui doit libérer. En fait, vous écrivez une fonction:
...

merci beaucoup pour votre résponse.
nous sommes débutants, donc nous ne sommes pas sûrs de comment faire ce que vous avez dit. s'il vous plaît, est-ce que vous pouviez nous montrer un exemple écrit de ce méthode?
merci d'avance.

[diogene]

- Si le mot comporte N caractères, alors il y a N manières de le couper en deux.
- Les chaînes constituées des deux mots obtenus par cette coupure ont N+1 caractères (à cause du blanc qui est ajouté) sauf la dernière qui a N caractères.

On peut donc :

- Allouer un tableau tab de N pointeurs sur char

- Pour i = 0 à i = N-2

- allouer un tableau de N+2 char et mettre son adresse dans tab[i]

- Copier la chaîne coupée en deux dans ce tableau : la première partie fait i+1 caractères, puis le blanc puis les caractères restants.

- allouer un tableau de N+1 char et mettre son adresse dans tab[N-1]

- copier la chaîne dans ce tableau

Eventuellement, on peut allouer pour tab N+1 pointeurs sur char et mettre le dernier à NULL pour signifier que le tableau de chaînes est terminé

[pc2-bresil]

- Si le mot comporte N caractères, alors il y a N manières de le couper en deux.
- Les chaînes constituées des deux mots obtenus par cette coupure ont N+1 caractères (à cause du blanc qui est ajouté) sauf la dernière qui a N caractères.

On peut donc :
...

merci, nous irons essayer d'utiliser cette idée, mais le problème est que il n'y aura pas toujours N divisions possibles (parce que nous pouvons vouloir diviser le mot de différentes manières - comme "che eval" - , en outre le manière que nous avons montré - c heval, ch eval, ...).

[diogene]

merci, nous irons essayer d'utiliser cette idée, mais le problème est que il n'y aura pas toujours N divisions possibles (parce que nous pouvons vouloir diviser le mot de différentes manières - comme "che eval" - , en outre le manière que nous avons montré - c heval, ch eval, ...).

Mais "che eval" n'est pas "cheval" coupé en 2. Que signifie précisément dans votre problème l'expression "diviser en deux parties" ?

[pc2-bresil]

Mais "che eval" n'est pas "cheval" coupé en 2. Que signifie précisément dans votre problème l'expression "diviser en deux parties" ?

réellement, la fonction revient "cheval" coupé en 2, mais nous voulons pouvoir ajouter dans le tableau de char*, dans une seule itération du for, autres formes de division en deux parties (comme, par exemple, "che eval").
réellement, cette fonction "cavaco" est seulement un exemple, parce que ce que nous voulons est une solution plus générale pour le problème de faire une fonction ajouter valeurs dans un tableau de char* e retourner ce tableau.
merci d'avance.

[samitriani]

A ce que je comprends tu veux faire retourner ce tableau de la fonction, et l'afficher dans le main() par exemple ??

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
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
int cavaco (char *x,char **Sortie)
{
  int a;
  char *pars1,*pars2;
  int taille_sortie = 0;
 
  for (a = 0; a < strlen(x); a++) {
    Sortie[a] = malloc(10*sizeof(char));
    pars1 = malloc((a+1) * sizeof(char));
    pars2 = malloc(((strlen(x) - a)+1) * sizeof(char));
    strncpy(pars1, x, a+1);
    pars1[a+1] = '\0';
    sprintf(pars2, "%s", &x[a+1]);
//     printf("%s %s\n", pars1, pars2);
    sprintf(Sortie[a],"%s %s",pars1,pars2);
    taille_sortie++;
    free(pars1);
    free(pars2);
  }
  return taille_sortie;
}
 
int main(int argc, char *argv[])
{
  char entre[]="cheval";
  char **Sort;
  int taille,i;
 
  Sort = malloc(10*sizeof(char *));
 
  taille = cavaco(entre,Sort);
  for(i = 0 ; i < taille ; i++)
  {
    printf("%s\n",Sort[i]);
  }
  return 0;
}

La fonction cavaco prends comme arguments un tableau en entrée x et un un tableau de chaines en sortie "Sortie". Cette fonction retourne le nombre d'elements dans le tableau de chaines Sortie.
Pour ce qui est des tailles des allocations et tableau j'ai fait ca un peu aléatoirement ..

[pc2-bresil]

saluts,

samitriani, nous avons modifié votre code un peu, mais nous ne savons pas si c'est correct:

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
int cavaco (char *x,char **Sortie)
{
  int a;
  char *pars1,*pars2;
  int taille_sortie = 0;
  for (a = 0; a < strlen(x); a++) {
    pars1 = malloc((a+1) * sizeof(char));
    pars2 = malloc(((strlen(x) - a)+1) * sizeof(char));
    strncpy(pars1, x, a+1);
    pars1[a+1] = '\0';
    sprintf(pars2, "%s", &x[a+1]);
    Sortie[a] = malloc((strlen(pars1) + strlen(pars2) + 2)*sizeof(char)); //<-- modifié
    sprintf(Sortie[a],"%s %s",pars1,pars2);
    taille_sortie++;
    free(pars1);
    free(pars2);
  }
  return taille_sortie;
}

dans cette modification, nous avons modifié la taille de chaque Sortie[a] dans le for à la taille de pars1 + " " + pars2 + '\0', pour être dynamique.
maintenant, la doute est: comment faire Sort = malloc(20*sizeof(char *));, l'allocation des char*, dynamique aussi? est-ce possible de modifier la taille du tableau de char* (le char **Sortie) dans chaque fois que nous ajoutons un char* dans Sortie?

[diogene]

réellement, la fonction revient "cheval" coupé en 2, mais nous voulons pouvoir ajouter dans le tableau de char*, dans une seule itération du for, autres formes de division en deux parties (comme, par exemple, "che eval")...

Vous voulez donc avoir un mot composé de tout ou partie du début du mot, suivi de tout ou partie de la fin du mot. Est-ce cela ?
Par exemple :
"c cheval", "c heval", "c eval",...."c l"
"ch cheval", "ch heval", ch eval",...."ch l"
"che cheval","che heval",....
....
Dans ce cas, on peut prévoir le nombre de chaînes à créer et leur longueur d'après le nombre de caractères du mot.

réellement, cette fonction "cavaco" est seulement un exemple, parce que ce que nous voulons est une solution plus générale pour le problème de faire une fonction ajouter valeurs dans un tableau de char* e retourner ce tableau.

Faire ajouter des valeurs dans le tableau de char* implique que le tableau est créé hors de la fonction ou que la fonction peut savoir que le tableau n'a pas déjà été créé, que la fonction reçoit également en argument la taille maximum du tableau et le nombre d'éléments occupés (ou que les éléments encore libres sont marqués par NULL). La fonction doit pouvoir augmenter la taille du tableau lorsque celui-ci est déjà plein, donc le tableau est créé par allocation dynamique (malloc) et redimensionné par realloc. Si la fonction doit faire un realloc, elle doit pouvoir renvoyer au code d'appel la nouvelle position du tableau et la nouvelle dimension maximum du tableau.

[pc2-bresil]

diogene: réellement, nous pensons que ce peut être possible de rédimensionner le tableau. dans la fonction que nous avons envoyé dans notre dernière réponse, "Sort" est créé hors de la fonction, mais une taille est spécifiée. (Sort = malloc(20*sizeof(char*))).
est-ce que nous pouvons définir char **Sort hors de la fonction sans spécifier son taille, utiliser comme argument (char **Sortie), et utiliser, comme vous avez dit, realloc dans chaque itération pour créer space pour un nouveau char* pour chaque division possible, en spécifier, donc, la taille de ce char* avec Sortie[a] = malloc((strlen(pars1) + strlen(pars2) + 2)*sizeof(char));, comme nous avons fait dans notre dernière réponse?
quelque chose comme:

Code :

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

1
2
 
Sortie = realloc((taille_sortie + 1)*sizeof(char*));

est-ce que cela a de sens?

merci d'avance.

[Pierre Maurette]

merci beaucoup pour votre résponse.
nous sommes débutants, donc nous ne sommes pas sûrs de comment faire ce que vous avez dit. s'il vous plaît, est-ce que vous pouviez nous montrer un exemple écrit de ce méthode?
merci d'avance.

A corriger en fonction de votre problème réel. Attention, "cheval" ne fait pas partir des retours. Penser à tester les malloc(). Ecriture à simplifier si syntaxe C99.

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct {
    int Nb;
    char** mots1;
    char** mots2;
    } scaveco;
 
 
scaveco cavaco(char *x)
{
	int a = 0;
	scaveco ret;
	ret.Nb = strlen(x) - 1;
	ret.mots1 = malloc(ret.Nb * sizeof *ret.mots1);
	ret.mots2 = malloc(ret.Nb * sizeof *ret.mots2);
	for (a = 0; a < ret.Nb; a++) {
		ret.mots1[a] = malloc(a * sizeof **ret.mots1);
		ret.mots2[a] = malloc((ret.Nb - a) * sizeof **ret.mots2);
		strncpy(ret.mots1[a], x, a+1);
		ret.mots1[a][a+1] = '\0';
		sprintf(ret.mots2[a], "%s", &x[a+1]);
	}
	return ret;
}
 
void cavaco_free(scaveco s)
{
	int a = 0;
	for (a = 0; a < s.Nb; a++) {
	    free(s.mots1[a]);
	    free(s.mots2[a]);
	}
	free(s.mots1);
	free(s.mots2);
}
 
 
int main(int argc, char *argv[])
{
    scaveco result = cavaco("cheval");
    int a;
    for(a = 0; a < result.Nb; a++){
        puts(result.mots1[a]);
        puts(result.mots2[a]);
    }
    cavaco_free(result);
    return EXIT_SUCCESS;
}

[nicolas.sitbon]

A corriger en fonction de votre problème réel. Attention, "cheval" ne fait pas partir des retours. Penser à tester les malloc(). Ecriture à simplifier si syntaxe C99.

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct {
    int Nb;
    char** mots1;
    char** mots2;
    } scaveco;
 
 
scaveco cavaco(char *x)
{
	int a = 0;
	scaveco ret;
	ret.Nb = strlen(x) - 1;
	ret.mots1 = malloc(ret.Nb * sizeof *ret.mots1);
	ret.mots2 = malloc(ret.Nb * sizeof *ret.mots2);
	for (a = 0; a < ret.Nb; a++) {
		ret.mots1[a] = malloc(a * sizeof **ret.mots1);
		ret.mots2[a] = malloc((ret.Nb - a) * sizeof **ret.mots2);
		strncpy(ret.mots1[a], x, a+1);
		ret.mots1[a][a+1] = '\0';
		sprintf(ret.mots2[a], "%s", &x[a+1]);
	}
	return ret;
}
 
void cavaco_free(scaveco s)
{
	int a = 0;
	for (a = 0; a < s.Nb; a++) {
	    free(s.mots1[a]);
	    free(s.mots2[a]);
	}
	free(s.mots1);
	free(s.mots2);
}
 
 
int main(int argc, char *argv[])
{
    scaveco result = cavaco("cheval");
    int a;
    for(a = 0; a < result.Nb; a++){
        puts(result.mots1[a]);
        puts(result.mots2[a]);
    }
    cavaco_free(result);
    return EXIT_SUCCESS;
}

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct 
{
   size_t Nb;
   char **mots1;
   char **mots2;
} scaveco;
 
void cavaco_free(scaveco **s);
scaveco *cavaco(char const *x);
 
int main (void)
{
    scaveco *result = cavaco("cheval");
    if (result != NULL)
    {
       size_t i = 0;
       for(i = 0; i < result->Nb; i++)
           printf ("%s %s\n",result->mots1[i], result->mots2[i]);
 
       cavaco_free (&result);
    }
    return EXIT_SUCCESS;
}
 
scaveco *cavaco(char const *x)
{
   scaveco *ret = NULL;
 
   if (x != NULL)
   {
      int err = 0;
 
      ret = malloc (sizeof *ret);
      if (ret != NULL)
      {    
         ret->Nb = strlen (x) - 1;
         ret->mots1 = malloc (ret->Nb * sizeof *ret->mots1);
         ret->mots2 = malloc (ret->Nb * sizeof *ret->mots2);
 
         if (ret->mots1 != NULL && ret->mots2 != NULL)
         {
            size_t i = 0;  
            for (i = 0; i < ret->Nb; i++) 
            {
               ret->mots1[i] = malloc (i * sizeof **ret->mots1);
               ret->mots2[i] = malloc ((ret->Nb - i) * sizeof **ret->mots2);
               if (ret->mots1[i] != NULL && ret->mots2[i] != NULL)
               {
                  strncpy (ret->mots1[i], x, i+1);
                  ret->mots1[i][i+1] = 0;
                  sprintf (ret->mots2[i], "%s", x + i + 1);
               }
               else
               {
                  err = 1;
                  break;
               }
            }
         }
         else
            err = 2;
      }
 
      if (err)
         cavaco_free (&ret);
   }
   return ret;
}
 
void cavaco_free(scaveco **s)
{
   if (s != NULL)
   {
      if (*s != NULL)
      {
         size_t i = 0;
 
         if ((*s)->mots1 != NULL)
         {
            for (i = 0; i < (*s)->Nb; i++) 
            {
               if ((*s)->mots1[i] != NULL)
                  free ((*s)->mots1[i]), (*s)->mots1[i] = NULL;
            }
            free ((*s)->mots1), (*s)->mots1 = NULL;
         }
 
         if ((*s)->mots2 != NULL)
         {
            for (i = 0; i < (*s)->Nb; i++) 
            {
               if ((*s)->mots2[i] != NULL)
                  free ((*s)->mots2[i]), (*s)->mots2[i] = NULL;
            }
            free ((*s)->mots2), (*s)->mots2 = NULL;
         }
 
         free (*s), *s = NULL;
      }
   }
}

[pc2-bresil]

merci beaucoup à vous.
mais - nous vous ennuierons de nouveau - il y a encore un problème.
c'est la ligne:

Code :

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

1
2
 
ret->Nb = strlen (x) - 1;

est-ce qu'il y a une manière de ne pas présumer que le nombre de résultats serait toujours strlen(x) - 1? par exemple, si nous voulons ajouter autres possibilités de division (que dépendent du mots1[a] et mots2[a] courant, et, donc, de nombre imprévisible si pas à l'intérieur du for).
est-ce que nous pouvons changer le nombre de résultats dynamiquement d'après necessité, en rédimensionner les tailles de ret.mots1 et ret.mots2 dans le for? quelque chose du genre (initialiser ret.Nb comme 1 en premier, par exemple):

Code :

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

1
2
3
 
ret.mots1 = realloc((ret.Nb++) * sizeof *ret.mots1);
ret.mots2 = realloc((ret.Nb++) * sizeof *ret.mots2);

nous sommes débutants, donc ce peut ne faire pas sens...

[diogene]

C'est effectivement possible de faire un realloc si nécessaire. Mais attention à n'incrémenter ret.Nb qu'une fois et à tester les retours de realloc.

La trame pourra être alors :

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
p = realloc( (ret.Nb+1)* sizeof *ret.mots1);
if( p!= NULL)
{
    ret.mots1 = p;
    q = realloc((ret.Nb+1) * sizeof *ret.mots2);
    if( q!= NULL) 
    {
      ret.mots2 = q;
      ret.Nb++;
    }
    else
    {
// échec de la réallocation de ret.mots2 
// ret.mots1 possède ret.Nb+1 éléments dont  ret.Nb utiles
// ret.mots2 possède ret.Nb éléments
    }
else
{
// échec de la réallocation de ret.mots1 
// ret.mots1 possède ret.Nb éléments
// ret.mots2 possède ret.Nb éléments
}

Réallouer 1 terme de plus à chaque fois multiplie les appels à realloc et il est possible d'en (re)allouer plus à chaque fois et de ne faire les réallocations que si elles deviennent nécessaires.