Jak wspominali inni, w C użyjesz memcpy
. Należy jednak pamiętać, że powoduje to wykonanie surowej kopii pamięci, więc jeśli struktury danych mają wskaźnik do siebie lub do siebie nawzajem, wskaźniki w kopii nadal będą wskazywać na oryginalne obiekty.
W C ++ można również użyć memcpy
, jeśli członkowie tablicy są POD (czyli zasadniczo typy, które można również użyte niezmienione w C), ale w ogóle, memcpy
będzie nie być dozwolone. Jak wspominali inni, funkcja do użycia to std::copy
.
Powiedziawszy to, w C ++ rzadko powinieneś używać surowych tablic. Zamiast tego powinieneś albo użyć jednego ze standardowych kontenerów ( std::vector
jest najbliższy wbudowanej tablicy, a także myślę, że najbliższy tablicom Java - rzeczywiście bliżej niż zwykłe tablice C ++ - ale std::deque
lub std::list
może być bardziej odpowiedni w niektórych przypadkach) lub, jeśli używasz C ++ 11, std::array
który jest bardzo zbliżony do tablic wbudowanych, ale z semantyką wartości, podobnie jak inne typy C ++. Wszystkie typy, o których tutaj wspomniałem, można skopiować przez przypisanie lub konstrukcję kopii. Co więcej, możesz "cross-copy" z opne do innego (a nawet z wbudowanej tablicy) używając składni iteratora.
Daje to przegląd możliwości (zakładam, że uwzględniono wszystkie odpowiednie nagłówki):
int main()
{
int a[] = { 1, 2, 3, 4 };
int b[4];
memcpy(b, a, 4*sizeof(int));
std::copy(a, a+4, b);
std::copy(std::begin(a), std::end(a), std::begin(b));
std::vector<int> va(a, a+4);
std::vector<int> vb = va;
std::vector<int> vc { 5, 6, 7, 8 };
vb = vc;
vb.assign(vc.begin(), vc.end());
std::vector<int> vd;
std::copy(va.begin(), va.end(), std::back_inserter(vd));
std::copy(a, a+4, vd.begin());
std::array<int, 4> sa = { 9, 10, 11, 12 };
std::array<int, 4> sb = sa;
sb = sa;
}
man memmove
iman memcpy