Erreur de segmentation allocation dynamique

Version imprimable

Bonjour.
Dans mon main je déclare
Code:

1 2 int ** T = NULL;
Ensuite j'appelle la fonction laquelle je veux allouer T
Code:

1 2 lecture (& T);
Dans lecture je fais ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 void lecture (int Nb, int *** pT) { int i; /* Allocation du tableau contenant les dimensions des objets Nb est le nombre d'objets. */ *pT = malloc ( Nb * sizeof ( int * ) ); assert (*pT); for (i = 0; i < Nb; i++) { *pT[i] = malloc ( 2 * sizeof ( int ) ); assert (*pT[i]); }
Et au quatrième passage de la boucle j'ai une erreur de segmentation.
Savez-vous pourquoi ?
Si oui, pouvez-vous m'indiquer comment m'y prendre dans la boucle ?

Merci à tous ceux qui prendront le temps de me lire.

PS : Je sais que je pourrais me contenter d'utiliser le return de la fonction pour renvoyer l'adresse de ma matrice (technique plus simple que je maîtrise déjà) mais je veux maîtriser cette technique en passant l'adresse de ma matrice en param.

Citation:

Ensuite j'appelle la fonction laquelle je veux allouer T

Je ne suis pas alèse encore avec les doubles pointeurs, mais normalement à ce moment vous devriez pointer sur l'adresse d'un pointeur.

Code:

1
2
3
4
5
6
7
8
9
10
11
int main(void)
{
    int **pointeur_double;
    int *pointeur;
    int a = 5;
    pointeur = &a; /* adresse de la variable */
    pointeur_double = &pointeur; /* adresse du pointeur */
    **pointeur_double = 25;
    printf("%d\n", a);
    return EXIT_SUCCESS;
}

Je ne comprend pas très bien le triple pointeur dans le paramètre de votre fonction.

Pourquoi tant détoiles, un entraînement aux pointeurs ou une nécessité selon vous?

En argument j'utiliserais donc que deux étoiles

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
void lecture (int Nb, int **pT)
{
	int i;
 
	/*
          Allocation du tableau contenant les dimensions des objets
          Nb est le nombre d'objets.
        */
	*pT = malloc ( Nb * sizeof ( int * ) );
 
	for (i = 0; i < Nb; i++) {
		pT[i] = malloc ( 2 * sizeof ( int ) );
		}
}
 
int main(void)
{
    int **pointeur_double;
    int *pointeur;
    int a = 5;
    pointeur = &a; /* adresse de la variable */
    pointeur_double = &pointeur; /* adresse du pointeur */
    lecture(5, pointeur_double);
    return EXIT_SUCCESS;
}

@baguiwoopy
C'est une question de priorité des opérateurs
Code:

1 2 3 for (i = 0; i < Nb; i++) { (*pT)[i] = malloc ( 2 * sizeof ( int ) ); assert ((*pT)[i]);

@ fred1599
Réponse incorrecte et inadaptée.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void lecture (int Nb, int **pT)
{
	int i;
	*pT = malloc ( Nb * sizeof ( int * ) );  
 //ERREUR : *pT est int* 
	for (i = 0; i < Nb; i++) {
		pT[i] = malloc ( 2 * sizeof ( int ) );  
 //ERREUR : incompatible avec l'allocation précédente
		}
}
 
int main(void)
{
    int **pointeur_double;
    int *pointeur;
    int a = 5;
    pointeur = &a; /* adresse de la variable */
    pointeur_double = &pointeur; /* adresse du pointeur */
 // inutiles et ne correspondent pas à la question.
    lecture(5, pointeur_double);
    return EXIT_SUCCESS;
}

28/04/2012, 09h26
fred1599

Merci diogene,

Je ne suis pas encore complètement alèse avec les pointeurs, et j'avais du mal à comprendre l'intérêt de mettre autant d'étoiles dans un paramètre de fonctions (peut-être as-tu la réponse?).

C'est vrai que j'essayais d'aider le PO, mais aussi de comprendre certaines choses, car l'allocation dynamique de ce style, j'en ai jamais fait ou eu l'utilité.

Merci pour tes explications...
28/04/2012, 18h02
baguiwoopy

Je ne comprend pas
@ diogene

Pourquoi tu me dis que c'est une histoire de priorité des opérateurs ?
Tu utilises la syntaxe
Code:

1 2 (*p)T
Alors que pT est une variable à part entière. Je ne comprends pas ta réponse :(.

@ fred1599

Merci quand même pour ta réponse mais elle ne répond pas vraiment à ma question :mrgreen:.
S'il y a trois étoiles en paramètres c'est parceque que ma fonction doit allouer de la mémoire à pT (la matrice). Si je lui passe seulement ma matrice en paramètre, j'alloue dynamiquement la variable temporaire crée par l'appel de fonction correspondante à la matrice.

Pourquoi cette technique ? Car dans la réalité ma fonction alloue dynamiquement plusieurs entités et je ne peux pas renvoyer l'adresse de tout le monde avec un return.

Bref pour l'instant je suis toujours coincé à part si j'ai mal compris diogène.
28/04/2012, 18h14
diogene

Je voulais écrire (*pT)[i] (et pas (*p)T[i] évidemment)
C'est une erreur de frappe de ma part et je me suis mal relu :oops:.
Je corrige mon post
28/04/2012, 18h26
baguiwoopy

It's okay !!

Bravo et merci diogène cela marche !
Pourrais-tu brièvement (ou pas ;) )m'expliquer ce que le compilateur comprenait sans les parenthèses stp?
Histoire que je puisse rajouter ce sujet sur la liste de mes acquis :mrgreen: !
28/04/2012, 21h48
diogene

Citation:

Pourrais-tu brièvement (ou pas )m'expliquer ce que le compilateur comprenait sans les parenthèses stp?
Histoire que je puisse rajouter ce sujet sur la liste de mes acquis !

*(pT[i]) autrement dit ce qui est ce qui est à l'adresse pT[i]