C++ equivalente a System.arraycopy de Java

Question

Estoy tratando de portar un código Java mío que hace un uso intensivo del método System.arraycopy y quiero saber si hay un equivalente en C++. Básicamente quiero tener matrices de n bytes y combinarlas en una gran matriz. Cada una de las matrices iniciales puede ser de longitud variable, por lo que no quiero pasar por el arcén de calcular la longitud de las matrices finales y luego llenar toda la matriz una posición a la vez, ya que esto parece bastante lento y estoy seguro de que esto la operación ha sido optimizada. Sin embargo, no puedo encontrar cuál es esta optimización (aunque puedo estar haciendo esto más complicado de lo que debería ser).

Aquí hay un código pseudo (Java) para ilustrar lo que quiero hacer.

byte[] a = new byte[]{0x00, 0x01, 0x02}; 
byte[] b = new byte[][0x03, 0x04, 0x05]; 
byte[] ab = new byte[a.length+b.length]; 
System.arraycopy(ab, 0, a, 0, a.length); 
System.arraycopy(ab, a.length+1, b, 0, b.length); 
//Now, I would expect ab to look like {0x00, 0x01, 0x02, 0x03, 0x04, 0x05} 

Como dije, esto puede ser simple en C++, pero me va a hacer esto muchas, muchas veces y querrá asegurarse de que lo estoy haciendo tan eficientemente como sea posible.

Answer 1

Dado a_len y b_len (que contiene la longitud en bytes de a y b), y un búfer dst lo suficientemente grande como para contener ambas matrices, puede usar memcpy. Nota: esto también depende de que dst se declare como un puntero a datos de tamaño de byte.

memcpy(dst, a, a_len); 
memcpy(dst+a_len, b, b_len); 

Esto funciona bien para los tipos primitivos (ya que parece que va a copiar matrices de bytes alrededor) ... Si tiene que copiar objetos, echar un vistazo a std :: copiar <>().

Answer 2

Prueba esto:

#include <vector> 

int main() 
{ 
    typedef unsigned char Byte; 
    std::vector<Byte> a; 
    std::vector<Byte> b; 
    // Fill vectors a and b 

    std::vector<Byte> ab; 
    // Reserve enough memory to fit a and b in order to avoid 
    // unnecessary reallocations. 
    ab.reserve(a.size() + b.size()); 
    ab.insert(ab.end(), a.begin(), a.end()); 
    ab.insert(ab.end(), b.begin(), b.end()); 

    return 0; 
} 

En C++, std::vector es su vecindario amigable dinámicamente matriz volver a tamaño considerable. Es tan rápido como las matrices normales para el acceso aleatorio. Merece la pena estudiar std::vector y otros contenedores/algoritmos en la biblioteca estándar. Recomiendo el libro de la biblioteca estándar de C++ por Josuttis.

vector::insert en vectores de tipos básicos probablemente será tan rápido como en C-style memcpy en C arrays. Estaría muy sorprendido si no fuera así.