Esiste una funzione per copiare un array in C / C ++?

Sono un programmatore Java che impara C / C ++. Quindi so che Java ha una funzione come System.arraycopy (); per copiare un array. Mi chiedevo se esiste una funzione in C o C ++ per copiare un array. Sono stato solo in grado di trovare l'implementazione per copiare un array utilizzando for loop, puntatori, ecc. C'è una funzione che posso usare per copiare un array?

A partire da C ++ 11, puoi copiare array direttamente con std::array:

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

Ecco la documentazione su std :: array

Dato che hai chiesto una soluzione 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));

Come altri hanno già detto, in C useresti memcpy . Si noti tuttavia che questo esegue una copia di memoria non elaborata, quindi se le strutture di dati hanno un puntatore a se stesse o tra loro, i puntatori nella copia punteranno comunque agli oggetti originali.

In C ++ è possibile utilizzare anche memcpyse i vostri membri di matrice sono POD (che è, essenzialmente i tipi che si potrebbe anche avete usato invariato in C), ma in generale, memcpysarà non essere consentito. Come altri menzionati, la funzione da usare èstd::copy .

Detto questo, in C ++ raramente dovresti usare array non elaborati. Invece dovresti usare uno dei contenitori standard ( std::vectorè il più vicino a un array integrato, e penso anche il più vicino agli array Java - più vicino dei semplici array C ++, in effetti -, ma std::dequeo std::listpotrebbe essere più appropriato in alcuni casi) oppure, se usi C ++ 11,std::array che è molto simile agli array incorporati, ma con semantica dei valori come altri tipi C ++. Tutti i tipi che ho menzionato qui possono essere copiati per incarico o copia di costruzione. Inoltre, puoi eseguire il "cross-copy" da opne a un altro (e persino da un array integrato) utilizzando la sintassi dell'iteratore.

Questo fornisce una panoramica delle possibilità (presumo siano state incluse tutte le intestazioni pertinenti):

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;
}

Puoi usare il memcpy(),

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

memcpy()copia i valori dei numbyte dalla posizione puntata da sourcedirettamente al blocco di memoria puntato da destination.

Se destinatione si sourcesovrappongono, puoi usare memmove().

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

memmove()copia i valori dei numbyte dalla posizione puntata da sourceal blocco di memoria puntato da destination. La copia avviene come se fosse utilizzato un buffer intermedio, consentendo la sovrapposizione di destinazione e sorgente.

Usa memcpyin C, std::copyin C ++.

Mi piace la risposta di Ed S., ma funziona solo per array di dimensioni fisse e non quando gli array sono definiti come puntatori.

Quindi, la soluzione C ++ in cui gli array sono definiti come puntatori:

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

Nota : non è necessario detrarre buffersizecon 1:

1. Copia tutti gli elementi nell'intervallo [primo, ultimo) a partire dal primo e procedendo fino all'ultimo - 1

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

In C puoi usare memcpy. In C ++ usa std::copydall'intestazione <algorithm>.

in C ++ 11 puoi usare Copy()che funziona per i contenitori std

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;
}

Fornisco qui 2 modi per gestire gli array, per il linguaggio C e C ++. memcpy e copy sono entrambi utilizzabili su C ++ ma copy non è utilizzabile per C, devi usare memcpy se stai cercando di copiare array in 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;
}

Basta includere la libreria standard nel codice.

#include<algorithm>

La dimensione dell'array sarà indicata come n

Il tuo vecchio Array

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

Dichiara New Array in cui devi copiare il tuo vecchio valore di array

int newArray[n];

Usa questo

copy_n(oldArray,n,newArray);

In primo luogo, poiché stai passando a C ++, si consiglia di utilizzare il vettore al posto del tradizionale array . Inoltre, copiare un array o un vettore std::copyè la scelta migliore per te.

Visita questa pagina per scoprire come utilizzare la funzione di copia: http://en.cppreference.com/w/cpp/algorithm/copy

Esempio:

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());