Discussion :

[kaikait]

Bonjour !

Voilà je me posais une question. Est-ce que

Code :

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

1
2
3
4
5
6
7
8
9
10
11
/**
 * I : tab -> un tableau de pointeur
 * O : aucun
 * P : fonction qui alloue au tableau NB_MAX_MENU * 40 octets au tableau
 **/
void allouer(char** tab)
{
  int i;
  for(i = 0; i < NB_MAX_MENU; i++)
    tab[i] = malloc(40 * sizeof(char));
}

est équivalent à

Code :

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

1
2
3
4
void allouer(char** tab)
{
  tab = malloc(40 * NB_MAX_MENU * sizeof(char));
}

?

Le tableau de pointeur envoyé est dans le premier cas :

Code :

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

char* texte[NB_MAX_MENU];

et dans le deuxieme cas :

Code :

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

char** texte;

Merci de vos réponse !


Edit : Par équivalent, j'entends au niveau de la gestion de mon programme, pas au niveau de la représentation en mémoire.


Cordialement,
Kev

[Fabllot]

Bonjour,

Non ce n'est pas pareil (à la fois en mémoire et pour ton programme)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
/**
 * I : tab -> un tableau de pointeur
 * O : aucun
 * P : fonction qui alloue au tableau NB_MAX_MENU * 40 octets au tableau
 **/
void allouer(char** tab)
{
  int i;
  for(i = 0; i < NB_MAX_MENU; i++)
    tab[i] = malloc(40 * sizeof(char));
}

Dans ce cas, tu sous-entends (ce qui est dangeureux) que le parametre est faite de type "char* tab [NB_MAX_MENU]".
Ceci dit, tu alloues pour chaque entrer de ton tableau de chaine de caractere, une chaine de caractere de longueur 40.

Code :

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

1
2
3
4
void allouer(char** tab)
{
  tab = malloc(40 * NB_MAX_MENU * sizeof(char));
}

Dans ce cas tu alloues une chaine de caractere de longueur 40*NB_MAX_MENU... et encore si tu n'as pas fait de segfault avant...

[Hoder]

Pour bien allouer un tableau, tu doi allouer la taille du "gros" tableau autant de fois qu'il y a d'elements, puis allouer de la memoire pour tout les "sous-tableaux". En gros, il ne faut pas faire soit l'un soit l'autre parmi ce que tu proposes, mais les deux (avec quelques modifications).

Code :

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

1
2
3
4
5
6
7
8
9
void allouer(char** tab)
{
   int  i;
   tab = malloc(([nombre d'elements] + 1) * sizeof(char*));
   for (i = 0 ; i <= [nombre d'element] ; i++)
        tab[i] = malloc(([longueur de la chaine] + 1)* sizeof(char));
    tab[i] = NULL;
}

Les +1 sont la pour reserver un espace memoire en plus pour mettre un '\0' a la fin.
La petite astuce si tu veux pas te melanger dans les sizeof, tu ecris * + l'element que tu malloc.
Par exemple :
Malloc tab -> sizeof(*tab) (cela va donc automatiquement allouer un char *)
Malloc tab[i] -> sizeof(*tab[i]) (cela va automatiquement allouer un char).
Si ta fonction est rattache a un projet, n'oublie pas de return (tab).

[Médinoc]

Si tu n'as pas l'intention de redimensionner ton tableau après l'avoir alloué, un truc de ce genre peut être utile:
http://www.developpez.net/forums/d28...c/#post1816773

[kaikait]

Si ça peut aider quelqu'un, on m'a pil poil ce que je cherchais répondu :

Si tu veux faire l'équivalent, contigue en mémoire il faut allouer :

Code :

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

tab = malloc((NB_MAX_MENU + 40 * NB_MAX_MENU) * sizeof(char));

Et mettre, pour (0<=i<NB_MAX_MENU), tab[i] = &tab[NB_MAX_MENU + 40*i];

J'avais trouvé une autre solution à mon problème et je n'ai donc pas testé ceci, mais cela me semble crédible.


Merci,
Kev