Je reçois une erreur de segmentation lorsque je passe les pointeurs doubles à la fonction pour initialiser la mémoire
int main() { double **A; initialize(A, 10, 10); ...... } void initialize(double **A, int r, int c) { A = (double **)malloc(sizeof(double *)*r); for(int i = 0; i< r; i++) { A[i] = (double *)malloc(sizeof(double) *c); for(int j = 0; j < c; j++) { A[i][j] = 0.0; } } }
Comment puis-je passer les doubles pointeurs vers les fonctions …..
Si vous souhaitez modifier un pointeur en pointeur, vous devez passer un pointeur à un pointeur à un autre.
void func(double ***data) { *data = malloc(sizeof(double*)*10); for.... }; double ** data; func(&data);
Comme d’autres l’ont dit, vous devez utiliser un pointeur à l’autre dans votre fonction init. Voici comment la fonction d’ initialize
change:
void initialize(double ***A, int r, int c) { *A = (double **)malloc(sizeof(double *)*r); for(int i = 0; i< r; i++) { (*A)[i] = (double *)malloc(sizeof(double) *c); for(int j = 0; j < c; j++) { (*A)[i][j] = 0.0; } } }
Et main
sera:
int main() { double **A; initialize(&A, 10, 10); }
De plus, le code tel que vous l'avez posté ne devrait causer aucune erreur de segmentation lors du passage du pointeur A
L'erreur de segmentation survient le plus souvent lorsque vous quittez la fonction et essayez d'accéder à A
, car A
in main
n'a pas été initialisé. De la façon dont vous le faites, seule une copie est initialisée. Cette copie est locale à la fonction initialize
. Elle est donc perdue à votre retour.
D’une part, l’initialisation interne de A
est une copie de A
main
– de sorte que lorsque vous revenez à main
, son A
n’est toujours pas initialisé. Si vous essayez de l’utiliser – boum!
Pour le passer à initialize
‘par référence’, vous devez changer le type de paramètre en double***
et passer en &A
dans main
. Ensuite, lorsque vous l’utilisez en initialize
, vous devez le déréférencer à chaque fois, c’est-à-dire *A
Vous ne vérifiez pas les erreurs de mémoire insuffisante. Échouer.
Vous passez PAR VALEUR une valeur non initialisée A pour initialiser (), puis l’initialiser. Mais revenons à main (), cette variable locale A n’a toujours pas été initialisée. Au lieu de cela, vous pourriez avoir initialize () renvoyer le double**
(par exemple, A = initialize(...)
) ou modifier initialize () afin que son premier paramètre formel soit un double ***pA
que vous initialisez avec *pA = (double**)malloc(...);
C’est le genre de chose que vous ne voulez pas faire. Au lieu d’utiliser inutilement un argument out pour cela, allouez la fonction et renvoyez le résultat. Faites ceci à la place:
int main() { double **A; A = initialize(A10, 10); } double** initialize(int r, int c) { double **A; A = malloc(sizeof(double *)*r); for(int i = 0; i< r; i++) { A[i] = (double *)malloc(sizeof(double) *c); for(int j = 0; j < c; j++) { A[i][j] = 0.0; } } return A; }