malloc sur tableau de chaine

**ishikawa** · 25/04/2007, 23h09

Salut,

Je cherche comment allouer un tableau de chaine de charactere manuellement,

pour un parseur de dossier, je voudrais récupérer chaque nom de fichier puis
le mémoriser dans un tableau afin pouvoir faire des comparaison entre deux fichiers plus facilement.

Le principe final du soft sera de supprimer les doublons de fichier dans un dossier tout d'abord en utilisant la taille en bit comme élément de comparaison puis évoluer vers md5.

donc je crée mon pointeur de tableau de chaine avec longueur de chaine fixe

char *sTab[256]

puis j'alloue le nombre de chaines du tableau en fonction du nombre de fichiers contenu dans le dossier.

sTab[256] = malloc( sizeof(char) * nbr_files);

est-ce la bonne méthode d'allocation?

Merci

**Thierry Chappuis** · 25/04/2007, 23h23

Envoyé par ishikawa

Salut,

Je cherche comment allouer un tableau de chaine de charactere manuellement,

pour un parseur de dossier, je voudrais récupérer chaque nom de fichier puis
le mémoriser dans un tableau afin pouvoir faire des comparaison entre deux fichiers plus facilement.

Le principe final du soft sera de supprimer les doublons de fichier dans un dossier tout d'abord en utilisant la taille en bit comme élément de comparaison puis évoluer vers md5.

donc je crée mon pointeur de tableau de chaine avec longueur de chaine fixe

puis j'alloue le nombre de chaines du tableau en fonction du nombre de fichiers contenu dans le dossier.

sTab[256] = malloc( sizeof(char) * nbr_files);

est-ce la bonne méthode d'allocation?

Merci

Le problème est qu'ici, tu déclares un tableau de 256 pointeurs sur char, alors que tu sembles (si j'ai bien compris ta question) vouloir la chose suivante:

Code :

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

1
2
/* pointeur sur un tableau de 256 chars */
char (*sTab)[256] = NULL;

L'allocation se passe alors comme suit:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
sTab = malloc(nbr_files * sizeof *sTab);
if (sTab != NULL)
{
    /* Le reste du code... */
 
    /* On n'oublie pas de libérer la mémoire allouée */
    free(sTab), sTab = NULL;
}
else
{
    fprintf(stderr, "Erreur d'allocation! Mémoire insuffisante...");
}

Thierry

**Lucien63** · 26/04/2007, 11h45

Code :

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

sTab = malloc(nbr_files * sizeof *sTab);

Ici tu alloues de l'espace pour un tableau de nbr_files pointeurs. ça ne correspond pas à la déclaration.

Moi j'aurais fait :

Code :

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

sTab = malloc(nbr_files * sizeof(char[256]));

(La déclaration est un pointeur sur des tableaux de 256 char).

**Médinoc** · 26/04/2007, 12h26

Lucien63 : Avec sTab de type char (*)[256], je ne suis pas sûr que tu aies raison...

**Lucien63** · 26/04/2007, 13h34

Envoyé par Médinoc

Lucien63 : Avec sTab de type char (*)[256], je ne suis pas sûr que tu aies raison...

Peut-être je me trompe !

mais char (*)[256] est bien un pointeur sur des tableaux char[256]

Alors tu l'alloue comment l'espace pour ces tableaux ?

(je ne pense pas que la taille d'un pointeur suffise pour allouer l'espace pour un tableau)

**Médinoc** · 26/04/2007, 13h37

sTab est de type char (*)[256], donc *sTab est de type char [256].

Pour le sizeof, c'est la même chose que si tu faisais:

Code :

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

1
2
char a[256];
printf("%d\n", (int)sizeof a);

**Lucien63** · 26/04/2007, 13h43

Ok, j'ai compris !

**Thierry Chappuis** · 26/04/2007, 15h27

Envoyé par Lucien63

Peut-être je me trompe !

mais char (*)[256] est bien un pointeur sur des tableaux char[256]

Alors tu l'alloue comment l'espace pour ces tableaux ?

(je ne pense pas que la taille d'un pointeur suffise pour allouer l'espace pour un tableau)

Il me semble avoir donné un exemple plus haut... http://www.developpez.net/forums/sho...14&postcount=2

[Edit] Par ailleurs, pour passer un tel tableau en paramètre d'une fonction, on fait la déclaration suivante:

Code :

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

void fonction(char (*tab)[256));

et pour déclarer une fonction qui retourne ce type de pointeurs, on utilise le prototype suivant (c'est assez amusant):

Code :

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

char (*fonction(void))[256];

Thierry

**ishikawa** · 26/04/2007, 23h27

En fait en C, les tableaux qui contiennent de chaines sont pas évidents à comprendre, du fait qu'une chaine est un tableau.

Moi mon but est simple: créer un tableau me permettant d'y enregistrer des noms de fichiers et ensuite pouvoir y acceder via un index entier.

Je sais qu'il existe des méthodes plus simple mais comprendre la plus compliquée me permettra d'aborder les autres avec plus de facilité.

Dans l'exemple de mujigka comment acceder à l'index, comment enregistrer des chaines dans ce tableau?

J'ai aussi un autre probleme, lorsque j'ecris

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
	char *tab;
	tab = malloc(sizeof(char));
 
    tab ="Servez a ce monsieur,le vieux petit juge blond assis au fond,une biere hollandaise et des kiwis, parce qu il y tient";
	printf("%s\n",tab);
 
 
	return 0;
}

Pourquoi en allouant un tableau de la taille d'un charactere, j'arrive à y placer une phrase plus grande que celle-ci?

**Thierry Chappuis** · 27/04/2007, 02h12

Envoyé par ishikawa

Pourquoi en allouant un tableau de la taille d'un charactere, j'arrive à y placer une phrase plus grande que celle-ci?

Parce que tab est un pointeur et il pointe vers la zone allouée par malloc(). Seulement voilà, lorsque tu réalises l'affectation suivante:

Code :

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

tab ="Servez a ce mo<...> parce qu il y tient";

Tu modifies la valeur de ton pointeur qui contient maintenant une adresse en mémoire statique où se trouve ta constante chaine de caractères "Servez a ce monsieur,le vieux petit juge blond assis au fond,une biere hollandaise et des kiwis, parce qu il y tient". Cette chaine n'est pas modifiable. En passant, tu as perdu l'adresse de ton espace mémoire alloué par malloc(), créant ainsi un joli trou de mémoire.

Pour l'exemple de code ci-dessous, nous supposerons toujours ta deuxième dimension constante et égale à 256 (tu supposes donc qu'aucune chaine ne dépassera la longueur de 255 caractères (!)). J'utilise des fonctions de saisie personnalisées qui se trouvent dans les fichiers io.h et io.c, à joindre au projet si tu veux le compiler (Je ne discute pas la saisie ici, une recherche sur le forum devrait te fournir de nombreux conseils relatifs à cette question). Voici donc le programme:

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
#include <stdio.h>
#include <stdlib.h>
#include "io.h"
 
#define CHAINES_LONG_MAX 256
 
int main(void)
{
    int err = EXIT_SUCCESS;
    int nchaines = 0;
 
    /* invite */
    printf("Commbien de chaines voulez-vous saisir? ");
    fflush(stdout);
 
    /* fonction de saisie d'un int déclarée dans io.h */
    if ((err = mget_int(&nchaines)) == IO_OK)
    {
        /* déclaration du pointeur */
        char (*chaines)[CHAINES_LONG_MAX] = NULL;
 
        chaines = malloc(nchaines * sizeof *chaines);
        /* On vérifie toujours que l'allocation est OK */
        if (chaines != NULL)
        {
            int i;
 
            /* Saisie des chaines entrées par l'utilisateur */
            for (i = 0; i< nchaines && !err; ++i)
            {
                printf("Saisissez la %d%s chaine: ", i+1, (i > 0) ? "ème":"ère");
                fflush(stdout);
                err = mget_line(chaines[i], sizeof chaines[0]);
            }
 
            if (i == nchaines) /* Toutes les chaines ont été saisies sans erreur */
            {
                /* Une fois la saisie terminée, on affiche toutes les chaines */
                printf("Vous avez saisi les chaines suivantes:\n");
 
                for (i = 0; i < nchaines; ++i)
                {
                    printf("%d: %s\n", i+1, chaines[i]);
                }
            }
            else /* Erreur de saisie */
            {
                fprintf(stderr, "Erreur de saisie de la chaine n°%d\n", i);
            }
 
            /* Finalement, on oublie pas de libérer la mémoire allouée */
            free(chaines), chaines = NULL;
        }
        else /* Erreur d'allocation*/
        {
            fprintf(stderr, "Erreur d'allocation! Mémoire insuffisante...\n");
            err = EXIT_FAILURE;
        }
    }
    else /* Erreur de saisie */
    {
        fprintf(stderr, "La saisie du nombre de chaines a échoué!\n");
    }
 
    return err;
}

Voici les fichiers à ajouter au projet lors de la compilation. Il contiennent des fonctions de saisie adaptées à la saisie d'une ligne et d'une entier de type int. Comme ce n'est pas le sujet de ce poste, je ne détaille pas ici.

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
/* Le fichier io.h */
#ifndef H_THIERRY_IO__
#define H_THIERRY_IO__
 
typedef enum IOError_ {
    IO_OK,
    IO_EOF,
    IO_ERR_NULL_ARG,
    IO_ERR_BUFF_SIZE,
    IO_ERR_BAD_INPUT,
    IO_ERR_FORMAT,
    IO_ERR_UNKNOWN
} IOError_e;
 
 
IOError_e mfget_line(char *s_buff, size_t buffsize, FILE *stream);
IOError_e mget_line(char *s_buff, size_t buffsize);
IOError_e mget_int(int *pnum);
 
#endif /* guard H_THIERRY_IO__ */

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
/* Le fichier io.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "io.h"
 
/* private functions */
 
static IOError_e
fclean(char *s_buff, FILE *stream)
{
    int err = IO_OK;
 
    if (s_buff != NULL)
    {
        /* On vérifie la présence du caractère '\n' dans le tampon */
        char *pc = strchr(s_buff, '\n');
 
        if (pc != NULL) /* Trouvé: la saisie est OK */
        {
            /* On efface le caractère de fin de ligne */
            *pc = 0;
        }
        else /* Pas trouvé: la saisie a été tronquée */
        {
            /* On vide le tampon du flux entrant */
            int c;
            while ((c = fgetc(stream)) != '\n' && c != EOF)
            {
                continue;
            }
            err = IO_ERR_BUFF_SIZE;
        }
    }
    return err;
}
 
/* public functions */
 
IOError_e mfget_line(char *s_buff, size_t buffsize, FILE *stream)
{
    IOError_e err = IO_OK;
 
    if (s_buff != NULL && stream != NULL)
    {
        if (buffsize >= 1)
        {
            if (fgets(s_buff, buffsize, stream) != NULL)
            {
                fclean(s_buff, stream);
            }
            else
            {
                err = IO_ERR_BAD_INPUT;
            }
        }
        else
        {
            err = IO_ERR_BUFF_SIZE;
        }
    }
    else
    {
        err = IO_ERR_NULL_ARG;
    }
    return err;
}
 
IOError_e mget_line(char *s_buff, size_t buffsize)
{
    return mfget_line(s_buff, buffsize, stdin);
}
 
IOError_e mget_int(int *pnum)
{
    IOError_e err = IO_OK;
    if (pnum != NULL)
    {
        char *pend = NULL;
 
        char s_buffer[15] = {0};
        if ((err = mfget_line(s_buffer, sizeof s_buffer, stdin)) == 0)
        {
            *pnum = strtol(s_buffer, &pend, 0);
            if (*pend != 0)
            {
                err = IO_ERR_FORMAT;
            }
        }
    }
    else
    {
        err = IO_ERR_NULL_ARG;
    }
    return err;
}

Thierry

**kazuo0** · 27/04/2007, 13h26

Et si tu faisais comme ca

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
 
#include <string.h>
#include <stdlib.h>
 
int	xstrlen(char *str)
{
  if (str)
    return(strlen(str));
  return (0);
}
 
void	*xmalloc(size_t size)
{
  void	*temp;
 
  if ((size <= (size_t)0))
    {
      printf("malloc: NULL\n");
      exit(0);
    }
  if (!(temp = malloc(size)))
    {
      printf ("malloc: error\n");
      exit(0);
    }
  return (temp);
}
 
void      foo(void)
{
 char	**tab;
 int    i;
 
 tab = (char **)xmalloc(sizeof(*tab) * ( nbr_files+ 1));
  for (i = 0; i < nbr_files; i++)
    tab[i] = (char *)xmalloc(sizeof(**tab) * (xstrlen(name_file)+ 1));
 return ;
}

**Emmanuel Delahaye** · 27/04/2007, 14h13

Envoyé par kazuo0

Et si tu faisais comme ca

Code :

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

1
2
3
4
5
6
7
8
9
10
void      foo(void)
{
 char	**tab;
 int    i;
 
 tab = (char **)xmalloc(sizeof(*tab) * ( nbr_files+ 1));
  for (i = 0; i < nbr_files; i++)
    tab[i] = (char *)xmalloc(sizeof(**tab) * (xstrlen(name_file)+ 1));
 return ;
}

Pas du C.

http://emmanuel-delahaye.developpez.....htm#tabdyn_2d

**Thierry Chappuis** · 27/04/2007, 14h23

Envoyé par kazuo0

Et si tu faisais comme ca

Code :

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

1
2
3
4
5
6
7
8
9
10
void      foo(void)
{
 char	**tab;
 int    i;
 
 tab = (char **)xmalloc(sizeof(*tab) * ( nbr_files+ 1));
  for (i = 0; i < nbr_files; i++)
    tab[i] = (char *)xmalloc(sizeof(**tab) * (xstrlen(name_file)+ 1));
 return ;
}

C'est pas très efficace de faire autant d'appels à malloc(). Si les deux dimensions du tableau peuvent varier, une allocation par dimension suffit:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
char ** tableau_chaines_creer(int n_chaines, int long_chaines)
{
    char **self = NULL;
 
    if (n_chaines > 0 && long_chaines > 0)
    {
        self = malloc(n_chaines * sizeof *self);
        if (self != NULL)
        {
            int taille = n_chaines * long_chaines * sizeof *self[0];
            self[0] = malloc(taille);
            if (self[0] != 0)
            {
                int i;
                for (i = 1; i < n_chaines; ++i)
                {
                    self[i] = &self[0][i*long_chaines];
                }
 
                /* initialisation des cases du tableau à 0 */
                memset(self[0], 0, taille);
            }
            else
            {
                /* Erreur d'allocation: on nettoie!!! */
                free(self), self = NULL;
            }
        }
    }
 
    return self;
}
 
void tableau_chaines_detruire(char ***self)
{
    if (self != NULL && *self != NULL)
    {
        free(*self[0]);
        free(*self), *self = NULL;
    }
}
 
int main(void)
{
    int err = EXIT_SUCCESS;
    int nb_chaines = 3;
    int longueur = 256;
 
    char **tableau = tableau_chaines_creer(nb_chaines, longueur);
    if (tableau != NULL)
    {
        /* Traitements sur le tableau */
 
        /* Libération de la mémoire */
        tableau_chaines_detruire(&tableau);
    }
    else
    {
        fprintf(stderr, "Allocation impossible! Mémoire insuffisante...");
        err = EXIT_FAILURE;
    }
 
    return err;
}

Les différentes méthodes pour créer un tableau dynamique à 2 dimensions sont résumées ici: http://c-faq.com/aryptr/dynmuldimary.html

Thierry

**Médinoc** · 27/04/2007, 14h24

Je trouve cette boucle d'allocation bien compliquée.
Se limiter à une allocation par dimension peut être plus intéressant:
http://www.developpez.net/forums/sho...70&postcount=7

Edit: Ah, grillé!

malloc sur tableau de chaine

C

Discussions similaires

Partager

Partager