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




pointer to array c++ (8)

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


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

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

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

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


Sie können memcpy() ,

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

memcpy() kopiert die Werte von num bytes von dem Ort, auf den die source verweist, direkt in den Speicherblock, auf den das destination .

Wenn sich das destination und die source überlappen, können Sie memmove() .

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

memmove() kopiert die Werte von num bytes von dem Ort, auf den die source memmove() in den Speicherblock, auf den das destination . Das Kopieren erfolgt so, als ob ein Zwischenpuffer verwendet würde, so dass sich Ziel und Quelle überlappen.


Wie andere bereits erwähnt haben, würden Sie in C memcpy . Beachten Sie jedoch, dass dies eine unformatierte Speicherkopie ist. Wenn Ihre Datenstrukturen einen Zeiger auf sich selbst oder auf einander haben, zeigen die Zeiger in der Kopie weiterhin auf die ursprünglichen Objekte.

In C ++ können Sie memcpy auch verwenden, wenn Ihre Array-Mitglieder POD sind (d. memcpy Im Wesentlichen Typen, die Sie möglicherweise auch in C unverändert verwendet haben). Im Allgemeinen ist memcpy jedoch nicht zulässig. Wie bereits erwähnt, ist die zu verwendende Funktion std::copy .

In C ++ sollten Sie jedoch selten rohe Arrays verwenden. Stattdessen sollten Sie entweder einen der Standardcontainer verwenden ( std::vector ist einem eingebauten Array am nächsten, und ich denke auch, dass es am nächsten an Java-Arrays liegt - näher als bei normalen C ++ - Arrays -, aber std::deque oder std::list ist in einigen Fällen möglicherweise passender) oder, wenn Sie C ++ 11 verwenden, std::array das sehr nahe an eingebauten Arrays liegt, jedoch mit Wertesemantik wie andere C ++ - Typen. Alle hier genannten Typen können durch Zuweisung oder Kopieren kopiert werden. Darüber hinaus können Sie mit Hilfe der Iteratorsyntax von opne zu einer anderen (und sogar von einem integrierten Array) "cross-copy".

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

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

In C ++ 11 können Sie Copy() , das für std-Container funktioniert

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

Erstens, da Sie zu C ++ wechseln, wird empfohlen, vector anstelle eines herkömmlichen Arrays zu verwenden . Um ein Array oder einen Vektor zu kopieren, ist std::copy die beste Wahl für Sie.

Besuchen Sie diese Seite, um zu erfahren, wie Sie die Kopierfunktion verwenden können: 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());

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


Verwenden Sie memcpy in C, std::copy in C ++.





arrays