it-swarm.com.de

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 frage mich, ob es in C oder C++ eine Funktion zum Kopieren eines Arrays gibt. Ich konnte die Implementierung zum Kopieren eines Arrays nur mithilfe von for-Schleife, Zeigern usw. finden. Gibt es eine Funktion, mit der ich ein Array kopieren kann?

70
J L

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

62
taocp

Da du nach einer C++ Lösung gefragt hast ...

#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.

Wie bereits erwähnt, würden Sie in C memcpy verwenden. Beachten Sie jedoch, dass hierdurch eine Rohspeicherkopie erstellt wird. Wenn Ihre Datenstrukturen also Zeiger auf sich selbst oder aufeinander haben, verweisen die Zeiger in der Kopie weiterhin auf die ursprünglichen Objekte.

In C++ können Sie auch memcpy verwenden, wenn Ihre Array-Mitglieder POD sind (dh im Wesentlichen Typen, die Sie auch unverändert in C hätten verwenden können), aber im Allgemeinen wird memcpynicht erlaubt sein. Wie bereits erwähnt, ist die zu verwendende Funktion std::copy.

In C++ sollten Sie jedoch selten unformatierte Arrays verwenden. Verwenden Sie stattdessen einen der Standardcontainer (std::vector ist einem eingebauten Array am nächsten, und ich denke auch, dass Arrays Java) am nächsten liegen - in der Tat näher als einfache C++ - Arrays -, aber std::deque oder std::list kann in einigen Fällen geeigneter sein) oder, wenn Sie C++ 11 verwenden, std::array, das den eingebauten Arrays sehr nahe kommt, aber wie andere C++ - Typen eine Wertesemantik aufweist. Alle hier genannten Typen können durch Zuweisung oder Kopierkonstruktion kopiert werden. Darüber hinaus können Sie mit Hilfe der Iteratorsyntax von einem geöffneten zu einem anderen (und sogar von einem eingebauten Array) "kopieren".

Dies gibt einen Überblick über die Möglichkeiten (ich gehe davon aus, dass alle relevanten Überschriften 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;
}
68
celtschk

Sie können die Funktion memcpy() verwenden,

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

memcpy() kopiert die Werte von num Bytes von der Position, auf die source zeigt, direkt in den Speicherblock, auf den destination zeigt.

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

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

memmove() kopiert die Werte von num Bytes von der Position, auf die source zeigt, in den Speicherblock, auf den destination zeigt. Das Kopieren erfolgt so, als würde ein Zwischenpuffer verwendet, sodass sich Ziel und Quelle überlappen.

17
Deepu

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

16
Mehrdad

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

10
Pete Becker

in C++ 11 können Sie Copy() verwenden, das für Standardcontainer 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;
}
3
MORTAL

Ich gebe hier 2 Möglichkeiten, Array für C und C++ Sprache zu bewältigen. memcpy und copy sind beide in C++ verwendbar, aber copy ist für C nicht verwendbar Verwenden von memcpy , wenn Sie versuchen, ein 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;
}
2
FaridLU

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.

Die C++ - Lösung, in der die Arrays als Zeiger definiert sind:

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

Anmerkung : Es ist nicht erforderlich, buffersize mit 1 abzuziehen:

1) Kopiert alle Elemente im Bereich [first, last) von first bis last - 1

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

1
DrumM

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

#include<algorithm>

Die Array-Größe wird als n bezeichnet.

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);
1
Ankit Singh

Erstens wird empfohlen, vector anstelle des herkömmlichen array zu verwenden, da Sie zu C++ wechseln. Außerdem, um ein Array oder einen Vektor zu kopieren, std::copy ist 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());