Existe-t-il une fonction pour copier un tableau en C/C++ ?

Question

Je suis un programmeur Java qui apprend le C/C++. Je sais donc que Java possède une fonction comme System.arraycopy() ; pour copier un tableau. Je me demandais s'il existait une fonction en C ou C++ pour copier un tableau. Je n'ai pu trouver que la mise en œuvre de la copie d'un tableau en utilisant la boucle for, les pointeurs, etc. Existe-t-il une fonction que je peux utiliser pour copier un tableau ?

Answer 1

Puisque vous avez demandé une solution 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));

Answer 2

Depuis C++11, vous pouvez copier des tableaux directement avec std::array :

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

Voici la documentation sur std::array

Answer 3

Comme d'autres l'ont mentionné, en C vous utiliseriez memcpy . Notez cependant qu'il s'agit d'une copie mémoire brute, donc si vos structures de données ont des pointeurs vers elles-mêmes ou entre elles, les pointeurs dans la copie pointeront toujours vers les objets originaux.

En C++, vous pouvez également utiliser memcpy si les membres de votre tableau sont des POD (c'est-à-dire, essentiellement des types que vous auriez également pu utiliser inchangés en C), mais en général, memcpy sera no être autorisé. Comme d'autres l'ont mentionné, la fonction à utiliser est std::copy .

Cela dit, en C++, il est rare que vous utilisiez des tableaux bruts. Vous devez plutôt utiliser l'un des conteneurs standard ( std::vector est ce qui se rapproche le plus d'un tableau intégré, et aussi, je pense, ce qui se rapproche le plus des tableaux Java - plus proche que les tableaux C++ ordinaires, en fait -, mais std::deque ou std::list peut être plus approprié dans certains cas) ou, si vous utilisez C++11, std::array qui est très proche des tableaux intégrés, mais avec une sémantique de valeur comme les autres types C++. Tous les types que j'ai mentionnés ici peuvent être copiés par affectation ou construction de copie. De plus, vous pouvez effectuer des "copies croisées" d'une opne à une autre (et même d'un tableau intégré) en utilisant la syntaxe des itérateurs.

Cela donne un aperçu des possibilités (je suppose que tous les en-têtes pertinents ont été inclus) :

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

Answer 4

Utilice memcpy en C, std::copy en C++.

Answer 5

Vous pouvez utiliser le memcpy() ,

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

memcpy() copie les valeurs de num octets de l'emplacement pointé par source directement dans le bloc de mémoire pointé par destination .

Si le destination y source se chevauchent, alors vous pouvez utiliser memmove() .

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

memmove() copie les valeurs de num octets de l'emplacement pointé par source au bloc de mémoire pointé par destination . La copie s'effectue comme si un tampon intermédiaire était utilisé, ce qui permet à la destination et à la source de se chevaucher.