web-dev-qa-db-fra.com

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

Je suis un programmeur Java qui apprend le c/c ++. Je sais donc que Java a une fonction similaire à System.arraycopy (); copier un tableau. Je me demandais s'il existe une fonction en C ou C++ pour copier un tableau. Je n'ai pu trouver qu'une implémentation pour copier un tableau en utilisant for, des pointeurs, etc. Existe-t-il une fonction que je peux utiliser pour copier un tableau?

c++carrays
70
J L

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

62
taocp

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));
113
Ed S.

Comme d'autres l'ont mentionné, en C, vous utiliseriez memcpy. Notez cependant qu'il s'agit d'une copie brute en mémoire. Par conséquent, si vos structures de données ont un pointeur sur elles-mêmes ou les unes sur les autres, les pointeurs de la copie pointeront toujours sur les objets d'origine.

En C++, vous pouvez également utiliser memcpy si vos membres du tableau sont POD (c'est-à-dire des types que vous auriez également utilisés sans modification en C), mais en général, memcpy will not être autorisé. Comme d'autres l'ont mentionné, la fonction à utiliser est std::copy.

Cela dit, en C++, vous devriez rarement utiliser des tableaux bruts. A la place, vous devriez soit utiliser l’un des conteneurs standard (std::vector est le plus proche d’un tableau intégré, et je pense aussi le plus proche des tableaux Java - plus proche que les tableaux C++ simples, en effet - , 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 d'autres types C++. Tous les types que j'ai mentionnés ici peuvent être copiés par construction d'assignation ou par copie. De plus, vous pouvez "cross-copier" d'une ope à une autre (et même à partir d'un tableau intégré) en utilisant la syntaxe de l'itérateur.

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

Vous pouvez utiliser la memcpy(),

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

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

Si destination et source se chevauchent, vous pouvez utiliser memmove().

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

memmove() copie les valeurs de num octets de l'emplacement désigné par source vers le bloc de mémoire désigné par destination. La copie a lieu comme si un tampon intermédiaire était utilisé, permettant ainsi à la destination et à la source de se chevaucher.

17
Deepu

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

16
Mehrdad

En C, vous pouvez utiliser memcpy. En C++, utilisez std::copy dans l'en-tête <algorithm>.

10
Pete Becker

en C++ 11, vous pouvez utiliser Copy() qui fonctionne pour les conteneurs 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;
}
3
MORTAL

Je donne ici 2 façons de faire face à tableau, pour les langages C et C++. memcpy et copie les deux sont utilisables en C++ mais la copie n'est pas utilisable en C, vous avez utiliser memcpy si vous essayez de copier un tableau 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;
}
2
FaridLU

J'aime la réponse de Ed S., mais cela ne fonctionne que pour les tableaux de taille fixe et non lorsque les tableaux sont définis comme des pointeurs.

Donc, la solution C++ où les tableaux sont définis comme des pointeurs:

    const int bufferSize = 10;
    char* origArray, newArray;
    std::copy(origArray, origArray + bufferSize, newArray);

Note : Inutile de déduire buffersize avec 1:

1) Copie tous les éléments de la plage [premier, dernier) en commençant par le premier et en passant au dernier - 1

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

1
DrumM

Incluez simplement la bibliothèque standard dans votre code.

#include<algorithm>

La taille du tableau sera notée n

Votre ancien tableau

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

Déclarer un nouveau tableau dans lequel vous devez copier votre ancienne valeur de tableau

int newArray[n];

Utilisez ceci

copy_n(oldArray,n,newArray);
1
Ankit Singh

Tout d’abord, parce que vous passez en C++, il est recommandé d’utiliser vector au lieu de l’ancien array. En outre, pour copier un tableau ou un vecteur, std::copy est le meilleur choix pour vous.

Visitez cette page pour savoir comment utiliser la fonction de copie: http://fr.cppreference.com/w/cpp/algorithm/copy

Exemple:

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());
1
Nhan Nguyen Tri Thanh