Cómo copiar valores de un puntero a otra

Question

Tengo el siguiente puntero:

jfloat *verticesLocal; 

Y quiero hacer una nueva copia a:

jfloat *vertices; 

quiero copiar los valores de verticesLocal a vertices.

¿Cómo puedo hacer eso? He intentado el siguiente comando, pero no funciona:

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

no puedo ver el error porque estoy trabajando con código nativo de Android. Lo siento.

Answer 1

malloc primero, luego haz tu memcpy.

Answer 2

¿Ha asignado memoria para vertices? De lo contrario, es probable que tengas un error de segmentación.

Answer 3

Si va a copiar el puntero, que es una tarea sencilla:

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

si usted quiere decir que desea copiar los datos de los puntos de punto a, usted tiene que asignar la memoria para el nuevo bloque de memoria primero:

// asume jfloat * verticesLocal apunta a un bloque de memoria válida con un tamaño i

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

Answer 4

La idea de "copiar un puntero", cuando se toma literalmente, no es más que una asignación simple.

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

En este caso, tanto p1 y p2 punto a los mismos datos - la int variable de x. Sin embargo, como esto es tan trivial, me inclino a pensar que lo que realmente pregunta es cómo copiar los datos a los que apunta el puntero.

En este caso, depende del tipo de datos. Si el puntero apunta a un simple buffer de PODs, esto implica asignar un buffer separado, y luego usar algo como memcpy (o preferiblemente std::copy) para copiar los datos. Por ejemplo:

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 

O bien, puede utilizar memcpy copiar el búfer de byte a byte, ya que el tampón contiene PODs.

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

Sin embargo, si al cual apunta a los datos es no un buffer simple, sino más bien un objeto de C++, no se puede utilizar memcpy. Necesitará realizar una copia del documento del objeto (generalmente usando el constructor de copia del objeto) para obtener un clon del objeto. Cómo se hace esto, o si es posible, depende del objeto. (Algunos objetos no son copiables.)

no tengo idea de lo que es un jfloat es, pero si el objeto es, por ejemplo, un std::string, usted acaba de hacer algo como:

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 

En este ejemplo artificioso que sería preferible evitar asignación de montón por completo, y solo use variables de pila. Pero demuestra la idea de copiar un objeto asignado en el montón.