Gibt es eine Funktion zum Kopieren eines Arrays in C / C ++?

Ich bin ein Java-Programmierer, der C / C ++ lernt. Ich weiß also, dass Java eine Funktion wie System.arraycopy () hat. um ein Array zu kopieren. Ich habe mich gefragt, ob es in C oder C ++ eine Funktion zum Kopieren eines Arrays gibt. Ich konnte nur eine Implementierung zum Kopieren eines Arrays finden, indem ich for-Schleife, Zeiger usw. Verwendete. Gibt es eine Funktion, mit der ich ein Array kopieren kann?

Seit C ++ 11 können Sie Arrays direkt kopieren mit std::array:

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

Hier ist die Dokumentation zu std :: array

Da Sie nach einer C ++ - Lösung gefragt haben ...

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

Wie andere bereits erwähnt haben, würden Sie in C verwenden memcpy. Beachten Sie jedoch, dass dies eine Rohspeicherkopie ausführt. Wenn Ihre Datenstrukturen also einen Zeiger auf sich selbst oder aufeinander haben, zeigen die Zeiger in der Kopie weiterhin auf die Originalobjekte.

In C ++ können Sie auch , memcpywenn Sie Ihre Array Mitglieder POD sind (die im wesentlichen Typen sind , die Sie auch unverändert in C verwendet haben könnten), aber im Allgemeinen memcpywird nicht erlaubt sein. Wie bereits erwähnt, ist die zu verwendende Funktion std::copy.

Allerdings sollten Sie in C ++ selten Raw-Arrays verwenden. Stattdessen sollten Sie entweder eine der Standardcontainer verwenden ( std::vectorist in der Nähe von einer eingebauten in Reihe, und auch ich denke , die am nächsten Java - Arrays - näher als einfachen C ++ Arrays, in der Tat - aber std::dequeoder std::listbesser geeignet in einigen Fällen) oder, wenn Sie C ++ 11 verwenden, std::arraydas den integrierten Arrays sehr nahe kommt, aber wie andere C ++ - Typen eine Wertsemantik aufweist. Alle hier genannten Typen können durch Zuordnung oder Kopierkonstruktion kopiert werden. Darüber hinaus können Sie mithilfe der Iteratorsyntax von opne zu einem anderen (und sogar von einem integrierten Array) "crosskopieren".

Dies gibt einen Überblick über die Möglichkeiten (ich gehe davon aus, dass alle relevanten Header enthalten sind):

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

Sie können die memcpy(), verwenden

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

memcpy()kopiert die Werte von numBytes von der Position, auf die gezeigt wird, sourcedirekt in den Speicherblock, auf den gezeigt wird destination.

Wenn sich das destinationund sourceüberlappen, können Sie verwenden memmove().

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

memmove()kopiert die Werte von numBytes von der Position, auf die gezeigt wird, sourcein den Speicherblock, auf den gezeigt wird destination. Das Kopieren erfolgt so, als ob ein Zwischenpuffer verwendet würde, sodass sich Ziel und Quelle überlappen können.

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

In C können Sie verwenden memcpy. In C ++ std::copyaus dem <algorithm>Header verwenden.

Ich mag die Antwort von Ed S., aber dies funktioniert nur für Arrays mit fester Größe und nicht, wenn die Arrays als Zeiger definiert sind.

Also die C ++ - Lösung, bei der die Arrays als Zeiger definiert sind:

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

Hinweis : buffersizeMit 1 muss nicht abgezogen werden:

1) Kopiert alle Elemente im Bereich [zuerst, zuletzt] vom ersten bis zum letzten - 1

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

In C ++ 11 können Sie dies Copy()für Standardcontainer verwenden

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

Ich gebe hier zwei Möglichkeiten zum Bewältigen von Arrays für C- und C ++ - Sprache. memcpy und copy sind beide unter C ++ verwendbar, aber copy ist für C nicht verwendbar. Sie müssen memcpy verwenden, wenn Sie versuchen, das Array in C zu kopieren.

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

Fügen Sie einfach die Standardbibliothek in Ihren Code ein.

#include<algorithm>

Die Arraygröße wird als bezeichnet n

Dein altes Array

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

Deklarieren Sie ein neues Array, in das Sie Ihren alten Array-Wert kopieren müssen

int newArray[n];

Benutze das

copy_n(oldArray,n,newArray);

Da Sie zu C ++ wechseln, wird zunächst empfohlen , den Vektor anstelle des herkömmlichen Arrays zu verwenden . Außerdem ist das Kopieren eines Arrays oder Vektors std::copydie beste Wahl für Sie.

Besuchen Sie diese Seite, um Informationen zur Verwendung der Kopierfunktion zu erhalten: http://en.cppreference.com/w/cpp/algorithm/copy

Beispiel:

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