web-dev-qa-db-fra.com

Comment copier des valeurs d'un pointeur à un autre

J'ai le pointeur suivant:

jfloat *verticesLocal;

Et je veux faire une nouvelle copie pour:

jfloat *vertices;

Je veux copier les valeurs de verticesLocal vers vertices.

Comment puis je faire ça? Je viens d'essayer la commande suivante, mais cela ne fonctionne pas:

memcpy(vertices, verticesLocal, numVerticesLocal * sizeof(jfloat));

Je ne vois pas l'erreur car je travaille avec Android code natif. Désolé.

c++pointersandroid-ndk
19
VansFannel

malloc d'abord, puis faites votre memcpy.

15
NPE

L'idée de "copier un pointeur", lorsqu'elle est prise au pied de la lettre, n'est rien d'autre qu'une simple affectation.

int x = 5;
int* p1 = &x;
int* p2 = p1; // there, we copied the pointer.

Dans ce cas, les deux p1 et p2 pointe sur les mêmes données - la variable intx. Cependant, parce que c'est si trivial, je suis enclin à penser que ce que vous demandez vraiment est de savoir comment copier le données vers lesquelles pointe le pointeur.

Dans ce cas, cela dépend du type de données. Si le pointeur pointe vers un simple tampon de PODs , cela implique d'allouer un tampon séparé, puis d'utiliser quelque chose comme memcpy (ou de préférence std::copy) pour copier les données. Par exemple:

int* p1 = new int[100];
// ... fill p1 with values
int* p2 = new int[100]; // create a new buffer
std::copy(p1, p1 + 100, p2); // copy the data into p2

Ou, vous pouvez utiliser memcpy pour copier le tampon octet par octet, car le tampon contient PODs .

memcpy(p2, p1, 100 * sizeof(int));

Cependant, si les données pointées ne sont pas pas un simple tampon, mais plutôt un objet C++, vous ne pouvez pas utiliser memcpy. Vous devez effectuer une copie en profondeur de l'objet (en utilisant généralement le constructeur de copie de l'objet) pour obtenir un clone de l'objet. La façon dont cela est fait, ou même si cela est possible, dépend de l'objet. (Certains objets ne sont pas copiables.)

Je n'ai aucune idée de ce qu'est un jfloat, mais si l'objet est, par exemple, un std::string, vous feriez simplement quelque chose comme:

std::string* s1; // assume this points to a valid string
std::string* s2 = new std::string();
*s2 = *s1; // copies s1 using s2's assignment operator

Dans cet exemple artificiel, il serait préférable d'éviter complètement l'allocation de tas et d'utiliser simplement des variables de pile. Mais il illustre l'idée de copier un objet alloué par segment de mémoire.

43
Charles Salvia

Si vous copiez le pointeur, c'est une affectation simple:

jfloat* verticesLocal; // assuming is is allocated already
jfloat* newVertices = verticesLocal;

SI vous voulez copier les données vers lesquelles le point pointe, vous devez d'abord allouer la mémoire pour le nouveau bloc de mémoire:

// suppose que jfloat * verticesLocal pointe vers un bloc de mémoire valide de taille i

jfloat* newVertices = new jfloat[i];
memcpy(newVertices, verticesLocal, i * sizeof(jfloat));
4
Zac Howland