Discussion :

[sperca]

Bonsoir,

Voilà je cherche à créer un tableau à deux dimensions dynamiquement dans un projet. Jusqu'à maintenant je déclarait le pointeur dans ma fonction et j'allouais normalement sans trop de problèmes. Or dans ce cas là, je souhaite avoir une fonction qui prend en paramètre un pointeur char*** tab et l'alloue dynamiquement suivant ce que je veux.
J'ai donc fait un petit programme simple pour tester, et malheureusement ça ne fonctionne pas du tout et je ne comprends pas pourquoi...

Pour l'instant ça segfault à partir des allocations dans le for, la deuxième je crois bien).

Voilà mon code :

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
 
int
parsage_options(char*** liste_rep_fic)
{
    int i = 0;
 
    if ((*liste_rep_fic = (char**) malloc(sizeof(char**) * 5)))
    {
	for (; i < 5; i++)
	{
	    if ((*liste_rep_fic[i] = (char*) malloc(sizeof(char*) * 5)))
	    {
		fprintf(stderr, "%p\n", *liste_rep_fic[i]);
		*liste_rep_fic[i][i] = 'a';
	    }
	}
    }
 
    return 1;
}
 
int
main(void)
{
    char** liste_rep_fic = NULL;
    int i = 0;
    int j = 0;
 
    parsage_options(&liste_rep_fic);
    fprintf(stderr, "%p\n", liste_rep_fic); 
    for (; i < 5; i++)
    {
	for (; j < 5; j++)
	{
	    printf("%c\n", liste_rep_fic[i][j]);
	}
    }
 
    return 0;
}

Merci à vous.

Bye.

[LittleWhite]

Bonjour,

Fais attention :

Ta fonction qui fait l'allocation ( parsage_options ) elle renvoie un int , que :
- Tu ne verifie pas dans le main , ce qui veut dire que le jour ou il ne pourras pas tout faire correctement , ton programme va continuer sans connaitre le problème ( soit sans s'arrêter )
- De plus le int que tu renvoie c'est toujours le même dans tout les cas. Ça veut dire que si un malloc plante , ta fonction ne le dira jamais au reste du programme.

De plus, d'après ce que j'arrive à comprendre du code , à la fin de la fonction ( parsage_options ) si elle ne plante pas tu aura un tableau remplie comme cela :

1 2 3 4 5
1 a
2 a
3 a
4 a
5 a

Les cases vides c'est que l'on ne sait pas ce qu'il y aura à l'intérieur.

Je proposerai pour simplifier le code une solution , ou la fonction parsage_options prendrait juste un char**

Du coup un truc plus compréhensible serait :

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
 
int parsage_options(char** liste_rep_fic)
{
	unsigned int i =0;
	unsigned int j = 0;
 
	if ( (liste_rep_fic = malloc(sizeof(char*)*5)) == NULL )
		return 0;
	for ( ; i < 5 ; i++ )
		if ( (liste_rep_fic[i] = malloc(sizeof(char)*5)) == NULL )
			return 0;
 
	// On remplit le tableau 
 
	for ( ; i < 5 ; i++ )
		for ( ; j<5 ; j++ )
			liste_rep_fic[i][j] = 'a';
 
	return 1;	// Tout c'est bien passer
}

Bien sur ne pas oublier d'enlever le '&' si t'utilise ma fonction.
Je pense que la mienne est plus simple , et plus juste.

Je viens de trouver exactement pourquoi ça plante sur ta fonction

Cette ligne :

Code :

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

((*liste_rep_fic = (char**) malloc(sizeof(char**) * 5)))

le " sizeof(char**) * 5 " a une étoile de trop
et pareil pour le prochain malloc


Il paraitrai , mais j'aimerais bien que quelqu'un confirme que l'on ne soit pas ( et que l'on ne devrait pas ) mettre le cast pour caster la valeur retournée du malloc? ( Il est très vrai que le compilateur ne dise rien sans )

[sperca]

Merci à toi,

Alors en fait, ce code n'est qu'un petit test, c'est pour ça que pour l'instant je ne me préoccupais pas du retour invariant. Et justement avec ta solution, je me retrouve avec le problème suivant :
Dans le main j'initialise le pointeur char** liste_rep_fic à NULL, donc vu que je le transmet à la fonction parsage option, une copie se crée et se pointeur restera à NULL donc segfault vu que j'essaye de parcourir le tableau juste après. C'est pour que j'utilisais le char*** qui justement me permet de le modifier.

Voilà.

Concernant le castage du malloc, je m'étais renseigné et effectivement tout le monde donne un peu son avis en contredisant les autres, donc pour l'instant je ne sais pas ^^.

Merci ;-).

Bye.

PS : donc là mon problème c'est que je ne comprends pas pourquoi mon code me donne un segfault... Car si j'utilise ** le pointeur reste à NULL dans la main et avec *** je ne parviens pas à el faire fonctionner....

[diogene]

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
int parsage_options(char*** liste_rep_fic)
{
    int i = 0;
    if ((*liste_rep_fic = malloc(sizeof(char*) * 5)))
    {
	     for (; i < 5; i++)
	     {
	        if (((*liste_rep_fic)[i] = malloc(sizeof(char) * 5)))
	        {
		        fprintf(stderr, "%p\n", (*liste_rep_fic)[i]);
		        (*liste_rep_fic)[i][i] = 'a';
	        }
	     }
    }
    return 1;
}

[sperca]

Merci beaucoup ;-).

Voilà c'est ça que je recherchais, donc en fait faut bien préciser que c'est un tableau de pointeurs sur char donc on l'encadre de parenthèses etc. (Gestion des priorités ?).

En tout je vais pouvoir avancer, merci encore.

Bye.

[orfix]

Quelques remarques :

• Des inclusions inutiles !
  

  Code :

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

  1
  2
  #include <string.h>
  #include <getopt.h>

• Une boucle for avec une expression (ou une initialisation) manquante ( comme c'est le cas ici ) c'est toujours louche!
  

  Code :

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

  1
  2
  3
  4
   
  for (; i < 5; i++)
  {
        for (; j < 5; j++)

  La preuve :
  

  Code :

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

  for (j=0; j < 5; j++)

• l'opérateur [] est plus prioritaire que * il est donc impértaif de paranthèser ce qui suit :
  

  Code :

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

  1
  2
  3
  if (((*liste_rep_fic)[i] = (char*) malloc(sizeof(char*) * 5)))
  
  (*liste_rep_fic)[i][i] = 'a';

• Des * en plus ( il faut revoir ton cours concernant les pointeurs ), au passage tu peux alléger tes allocations en retirant les casts (pas trop utiles ici) :
  

  Code :

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

  1
  2
  *liste_rep_fic = malloc(sizeof(char**) * 5)
  (*liste_rep_fic)[i] = malloc(5)

• Par contre, ici le cast est utile :
  

  Code :

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

  fprintf(stderr, "%p\n", (void*)liste_rep_fic);

• À quoi sert :
  

  Code :

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

  return 1;

• Finalement libérer la mémoire allouer dès qu'on en a plus besoin, renseigne toi sur free et son utilisation.

[sperca]

Merci pour ces remarques.

Pour les inclusions inutiles c'est "normal", c'était juste un test pour incorporer ça dans un projet.

Bye.