¿Existe una función para copiar una matriz en C / C ++?

Soy un programador de Java que aprende C / C ++. Entonces sé que Java tiene una función como System.arraycopy (); para copiar una matriz. Me preguntaba si hay una función en C o C ++ para copiar una matriz. Solo pude encontrar la implementación para copiar una matriz usando for loop, punteros, etc. ¿Hay alguna función que pueda usar para copiar una matriz?

Desde C ++ 11, puede copiar matrices directamente con std::array:

std::array<int,4> A = {10,20,30,40};
std::array<int,4> B = A; //copy array A into array B

Aquí está la documentación sobre std :: array

Dado que solicitó una solución C ++ ...

#include <algorithm>
#include <iterator>

const int arr_size = 10;
some_type src[arr_size];
// ...
some_type dest[arr_size];
std::copy(std::begin(src), std::end(src), std::begin(dest));

Como han mencionado otros, en C usaría memcpy . Sin embargo, tenga en cuenta que esto hace una copia de memoria sin formato, por lo que si sus estructuras de datos tienen un puntero a sí mismas o entre sí, los punteros en la copia seguirán apuntando a los objetos originales.

En C ++ también se puede utilizar memcpysi los miembros de la matriz son POD (es decir, tipos esencialmente que también se podría haber utilizado sin cambios en C), pero, en general, memcpyserá no ser permitido. Como han mencionado otros, la función a utilizar esstd::copy .

Habiendo dicho eso, en C ++ rara vez debería usar matrices sin procesar. En su lugar, debe usar uno de los contenedores estándar ( std::vectores el más cercano a una matriz incorporada, y también creo que es el más cercano a las matrices de Java, más cerca que las matrices de C ++ simples, de hecho, pero std::dequeo std::listpuede ser más apropiado en algunos casos) o, si usa C ++ 11,std::array que está muy cerca de las matrices integradas, pero con semántica de valor como otros tipos de C ++. Todos los tipos que mencioné aquí se pueden copiar por asignación o construcción de copia. Además, puede realizar una "copia cruzada" de opne a otro (e incluso de una matriz incorporada) utilizando la sintaxis de iterador.

Esto brinda una descripción general de las posibilidades (supongo que se han incluido todos los encabezados relevantes):

int main()
{
  // This works in C and C++
  int a[] = { 1, 2, 3, 4 };
  int b[4];
  memcpy(b, a, 4*sizeof(int)); // int is a POD

  // This is the preferred method to copy raw arrays in C++ and works with all types that can be copied:
  std::copy(a, a+4, b);

  // In C++11, you can also use this:
  std::copy(std::begin(a), std::end(a), std::begin(b));

  // use of vectors
  std::vector<int> va(a, a+4); // copies the content of a into the vector
  std::vector<int> vb = va;    // vb is a copy of va

  // this initialization is only valid in C++11:
  std::vector<int> vc { 5, 6, 7, 8 }; // note: no equal sign!

  // assign vc to vb (valid in all standardized versions of C++)
  vb = vc;

  //alternative assignment, works also if both container types are different
  vb.assign(vc.begin(), vc.end());

  std::vector<int> vd; // an *empty* vector

  // you also can use std::copy with vectors
  // Since vd is empty, we need a `back_inserter`, to create new elements:
  std::copy(va.begin(), va.end(), std::back_inserter(vd));

  // copy from array a to vector vd:
  // now vd already contains four elements, so this new copy doesn't need to
  // create elements, we just overwrite the existing ones.
  std::copy(a, a+4, vd.begin());

  // C++11 only: Define a `std::array`:
  std::array<int, 4> sa = { 9, 10, 11, 12 };

  // create a copy:
  std::array<int, 4> sb = sa;

  // assign the array:
  sb = sa;
}

Puedes usar el memcpy(),

void * memcpy ( void * destination, const void * source, size_t num );

memcpy()copia los valores de numbytes de la ubicación apuntada por sourcedirectamente al bloque de memoria apuntado por destination.

Si destinationy se sourcesuperponen, puede usar memmove().

void * memmove ( void * destination, const void * source, size_t num );

memmove()copia los valores de numbytes desde la ubicación apuntada por sourceal bloque de memoria apuntado por destination. La copia se realiza como si se utilizara un búfer intermedio, lo que permite que el destino y la fuente se superpongan.

Usar memcpyen C, std::copyen C ++.

Me gusta la respuesta de Ed S., pero esto solo funciona para matrices de tamaño fijo y no cuando las matrices están definidas como punteros.

Entonces, la solución de C ++ donde las matrices se definen como punteros:

#include<algorithm>
...
const int bufferSize = 10;
char* origArray, newArray;
std::copy(origArray, origArray + bufferSize, newArray);

Nota : No es necesario deducir buffersizecon 1:

1. Copia todos los elementos en el rango [primero, último) comenzando desde el primero y continuando hasta el último - 1

Ver: https://en.cppreference.com/w/cpp/algorithm/copy

En C puedes usar memcpy. En C ++, use std::copydel <algorithm>encabezado.

en C ++ 11 puede usar Copy()que funcione para contenedores estándar

template <typename Container1, typename Container2>
auto Copy(Container1& c1, Container2& c2)
    -> decltype(c2.begin())
{
    auto it1 = std::begin(c1);
    auto it2 = std::begin(c2);

    while (it1 != std::end(c1)) {
        *it2++ = *it1++;
    }
    return it2;
}

Doy aquí 2 formas de hacer frente a la matriz, para lenguaje C y C ++. memcpy y copy se pueden usar en C ++ pero la copia no se puede usar para C, debe usar memcpy si está intentando copiar una matriz en C.

#include <stdio.h>
#include <iostream>
#include <algorithm> // for using copy (library function)
#include <string.h> // for using memcpy (library function)


int main(){

    int arr[] = {1, 1, 2, 2, 3, 3};
    int brr[100];

    int len = sizeof(arr)/sizeof(*arr); // finding size of arr (array)

    std:: copy(arr, arr+len, brr); // which will work on C++ only (you have to use #include <algorithm>
    memcpy(brr, arr, len*(sizeof(int))); // which will work on both C and C++

    for(int i=0; i<len; i++){ // Printing brr (array).
        std:: cout << brr[i] << " ";
    }

    return 0;
}

Solo incluye la biblioteca estándar en tu código.

#include<algorithm>

El tamaño de la matriz se indicará como n

Tu vieja matriz

int oldArray[n]={10,20,30,40,50};

Declare una nueva matriz en la que debe copiar el valor de su matriz anterior

int newArray[n];

Utilizar esta

copy_n(oldArray,n,newArray);

En primer lugar, debido a que está cambiando a C ++, se recomienda usar vector en lugar de la matriz tradicional . Además, para copiar una matriz o un vector,std::copy es la mejor opción para ti.

Visite esta página para obtener información sobre cómo utilizar la función de copia: http://en.cppreference.com/w/cpp/algorithm/copy

Ejemplo:

std::vector<int> source_vector;
source_vector.push_back(1);
source_vector.push_back(2);
source_vector.push_back(3);
std::vector<int> dest_vector(source_vector.size());
std::copy(source_vector.begin(), source_vector.end(), dest_vector.begin());