malloc sur tableau de chaine

Version imprimable

25/04/2007, 23h09
ishikawa

malloc sur tableau de chaine

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

Citation:

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

Citation:

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:

1 2 /* pointeur sur un tableau de 256 chars */ char (*sTab)[256] = NULL;
L'allocation se passe alors comme suit:
Code:

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

26/04/2007, 11h45
Lucien63

Code:

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:

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

(La déclaration est un pointeur sur des tableaux de 256 char).
26/04/2007, 12h26
Médinoc

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

Citation:

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 ! :aie:
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)
26/04/2007, 13h37
Médinoc
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:

1 2 char a[256]; printf("%d\n", (int)sizeof a);
26/04/2007, 13h43
Lucien63

Ok, j'ai compris ! :aie:
26/04/2007, 15h27
Thierry Chappuis

Citation:

Envoyé par Lucien63

Peut-être je me trompe ! :aie:
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:

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:

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

Thierry

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:

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?

Citation:

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:

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:

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:

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:

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

Et si tu faisais comme ca

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

Citation:

Envoyé par kazuo0

Et si tu faisais comme ca

Code:

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

Citation:

Envoyé par kazuo0

Et si tu faisais comme ca

Code:

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:

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

27/04/2007, 14h24
Médinoc

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