Comment memcpy travail sur les pointeurs de tableaux?

J'ai initialiser 2 tableaux comme suit:

x = (double*) malloc(sizeof(double)*n);
xPlus1 = (double*) malloc(sizeof(double)*n);

Tout d'abord, je ne suis pas certain de ce que x ou xPlus1 maintenant, un pointeur vers un tableau de double, ou un tableau de pointeurs vers des doubles? :/

La réponse à cette question probablement des effets de cela, mais si je fais ces diverses opérations, je n'arrive pas à faire ce que je veux, qui est juste à copier les valeurs d'xPlus1 dans x. xPlus1 et x ont des valeurs différentes pour chaque indice, parce que l'impression après une simple boucle for obtient l'effet désiré:

for (int i = 0; i < n; i++) {
    x[i] = xPlus1[i];
}

Mais à l'aide de...

memcpy(x, xPlus1, sizeof(x));
memcpy(x, &xPlus1, sizeof(x)); 

Si j'ai accès x après l'un de ces, dans la même fonction, x est inchangé, de même conservé ses anciennes valeurs.

memcpy(&x, &xPlus1, sizeof(x)); 

Je crois que cela fait x et xPlus1 pointer vers le même emplacement de mémoire par les produits que je reçois. C'est parce que si je modifie x ou xPlus1 après cette copie, puis les deux valeurs de changer si je imprimer les deux tableaux.

memcpy(&x, xPlus1, sizeof(x)); 

Meurt, exception: exception non Gérée à 0x011D5626 dans MPITemplate.exe: 0xC0000005: violation d'Accès de l'écriture de l'emplacement 0x00000000.

L'esperluette dans les fonctions indiquent généralement un passage par référence, quelle est la situation lorsqu'il est administré à memcpy, et quelle différence cela fait-il si c'est pour écrire sur les mêmes blocs à la fin?

Je vous en serais reconnaissant si quelqu'un pouvait me dire en détail ce qu'il se passe avec ces opérations, parce que je peux bidouiller pour le faire fonctionner, mais je préfère comprendre ce qui se passe réellement lorsque ces appels sont effectués.

Merci,

Mike

  • xPlus1 est DÉJÀ un pointeur vers la fonction malloc avais de la mémoire. lorsque vous ne &xPlus1 vous obtenez l'adresse du pointeur lui-même, PAS le malloc avais de la mémoire. par exemple, vous n'êtes pas de copie dans votre malloc bloc, vous les copiez dans où le pointeur existe et bousiller tout autre chose qui vient après lui.
  • avez-vous essayé memcpy(x, xPlus1, n * sizeof(double));?
  • x est un double pointeur pointant sur un bloc de mémoire alloué pour n éléments doubles. xplus1 est également faire le même, mais ils sont dans différents emplacements de mémoire. si vous imprimez les adresses pour tous les xs et xplus1s, vous verrez qu'ils sont tous différents. Si vous utilisez des &x comme argument, vous êtes à l'aide du pointeur de pointeur, ce qui n'est pas correct. L'exception que vous avez obtenu est fondamentalement vous dire que, parce que vous avez été la copie et de l'écriture et de la lecture à partir du même emplacement simultanément, vous avez des problèmes d'accès.
  • Je reçois les pointeurs de pointeurs à défaut puis, je suppose que c'est juste de la chance qu'il ne tue pas le programme lorsque j'utilise memcpy(x, &xPlus1, sizeof(x)); je pense donc que c'est à l'aide de la taille du pointeur de la 'x' lorsque je place sizeof(x) n'est pas la taille du tableau il des points de? Je vais essayer à l'aide de n * sizeof(double)
  • la chance est simplement une consolation. si vous regardez la documentation de memcpy, il dit void * memcpy ( void * destination, const void * source, size_t num ); vous pouvez clairement voir que les memcpy(x, xPlus1, sizeof(x)) est bon pour vous. Aussi, le const source bits signifie que votre source de données n'est pas modifié, ce qui vous l'a fait et d'avoir l'erreur de violation d'accès lorsque vous avez essayé de pointeur de pointeur.
  • À toutes fins utiles, memcpy se comporte exactement de la même manière, si vous passez un pointeur (qui est ce que x et xPlus1 sont), ou d'un tableau. Tout simplement parce que les tableaux de désintégration dans les pointeurs lorsqu'il est passé à des fonctions. Votre pointeurs point à un bloc de mémoire alloué à l'aide malloc, ce bloc peut être traitée comme un tableau, donc, de copier le contenu de la mémoire x points de xPlus1, vous avez simplement à faire memcpy(xPlus1, x, n*sizeof *x);
  • BTW: Ne jette pas le résultat de malloc()
  • Devrait avoir mentionné que je suis en train d'écrire en C++, j'ai eu une lecture de la question, je ne pense pas que je peux le contourner en C++ comme dans le fichier d'en-tête x est déclaré comme un pointeur vers un double (double*)
  • Juste assez. Mais alors, pourquoi malloc() en premier lieu?
  • Bon point, je vois il y a d'autres façons d'initialiser les tableaux en C++, même avec les entrées dynamiques (bien qu'il semble que si je veux variable tailles pas connu au moment de l'exécution pour les deux dimensions du tableau, j'avais besoin de boucle), est-il un avantage par rapport à l'aide de malloc vraiment bien? J'ai fait presque toute ma programmation en C#, donc n'ai pas rencontré de cette baisse de niveau de type de codage avant de vraiment.
  • Il y a des. Sauf si vous êtes sûr à 100% que vous savez exactement ce que vous faites et pourquoi, ne pas utiliser de malloc(). Utiliser les new - similaire à C#, à l'exception que vous avez à gérer la mémoire. Mieux encore, utiliser les std::make_unique et std::make_shared selon le cas. Encore mieux (dans la mesure du raisonnable): utilisation de la pile par défaut de l'allocation et de copier les valeurs. Ne pas utiliser des tableaux, utiliser std::vector et std::array.
  • new initialise l'objet. C'est aussi plus de type sécurisé, et permet à l'allocateur de faire son travail plus efficacement. Voir ici: parashift.com/c++-faq/new-vs-malloc.html

InformationsquelleAutor starlight54 | 2014-11-04