I know that Java has a function System.arraycopy();
to copy an array. I was wondering if there is a function in C or C++ to copy an array. I was only able to find implementations to copy an array by using for
loops, pointers, etc. But is there a library function that I can use to copy an array?
14 Answers
Since you asked for a C++ solution...
#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));
-
4
-
28@David天宇Wong: You're using an old compiler or you didn't include the header. It's in
<iterator>
Commented Sep 1, 2014 at 17:54 -
11Maybe you should say which includes you need. Is copy in
<algorithm>
? Commented Dec 6, 2016 at 23:13 -
25I only ask because if you had to explain that std::begin was in <iterator> that means people are not googling std::begin to find out what header it is in so they are unlikely to google std::copy for the same reason. It makes a better answer if nobody has to ask stuff that is only answered in comments. Maybe I should have just edited the answer instead of prompting you to do it. Commented Dec 8, 2016 at 0:56
-
7you can change begin(src) into src and end(src) into src+arr_size– CalvinCommented Nov 10, 2018 at 15:57
Since C++11, you can copy arrays directly with std::array
:
#include <array>
std::array<int, 4> A = {10, 20, 30, 40};
std::array<int, 4> B = A; // Copy array A into array B
-
@XAleXOwnZX: The same you would any other type that supports copy assignment.
B = A
.– swalogCommented Mar 18, 2015 at 14:11 -
2I think the function is copy A's memory address to B. If I try to copy A's item values to B without changing B's memory address. How can I do that? Commented Apr 26, 2017 at 10:38
-
@Aaron_Lee: I've just tested it, and it genuinely copies the elements into an array in a separate memory location. The array class evidently has its own overload for the assignment operator. Commented Oct 21, 2019 at 10:03
-
17You guys realize that no assignment operators appeared in those two lines of code, right? That's the copy constructor that is being called even though the notation looks like the assignment operator. Commented Nov 20, 2019 at 22:18
As others have mentioned, in C you would use memcpy
. Note however that this does a raw memory copy, so if your data structures have pointer to themselves or to each other, the pointers in the copy will still point to the original objects.
In C++ you can also use memcpy
if your array members are POD (that is, essentially types which you could also have used unchanged in C), but in general, memcpy
will not be allowed. As others mentioned, the function to use is std::copy
.
Having said that, in C++ you rarely should use raw arrays. Instead you should either use one of the standard containers (std::vector
is the closest to a built-in array, and also I think the closest to Java arrays — closer than plain C++ arrays, indeed —, but std::deque
or std::list
may be more appropriate in some cases) or, if you use C++11, std::array
which is very close to built-in arrays, but with value semantics like other C++ types. All the types I mentioned here can be copied by assignment or copy construction. Moreover, you can "cross-copy" from opne to another (and even from a built-in array) using iterator syntax.
This gives an overview of the possibilities (I assume all relevant headers have been included):
#include <vector>
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;
}
-
why are you writing std all the time instead of just using the namespace of std ???– BlackCommented Jun 30, 2015 at 7:04
-
-
A Java array is more like
std:array
than likestd::vector
, because it has a fixed size. Commented Jan 20, 2016 at 15:59 -
Does
std::begin()
buy you anything in your second example ofstd::copy
?– wcochranCommented Aug 12, 2016 at 15:10 -
@wcochran: Yes: Should you ever decide to rewrite the code to use an actual container instead of a built-in array, you will not have to change that line. The less code you need to change, the less bugs you will introduce (and the less work you will have).– celtschkCommented Aug 12, 2016 at 16:01
Use memcpy
in C, std::copy
in C++.
You can use the memcpy()
,
void * memcpy ( void * destination, const void * source, size_t num );
memcpy()
copies the values of num
bytes from the location pointed by source
directly to the memory block pointed by destination
.
If the destination
and source
overlap, then you can use memmove()
.
void * memmove ( void * destination, const void * source, size_t num );
memmove()
copies the values of num
bytes from the location pointed by source
to the memory block pointed by destination
. Copying takes place as if an intermediate buffer were used, allowing the destination and source to overlap.
-
3Gonna have to -1 here. The OP is specifically asking for a C++ solution and this answer says nothing of the situations in which
memcpy
is wrong, i.e., copying bytes is insufficient. Commented Apr 22, 2013 at 1:18 -
3@EdS. In case you haven't noticed, the OP is now asking for a C or C++ solution.– autisticCommented Apr 22, 2013 at 2:15
-
6When I answered the OP was asking for C/C++ solutions, though I personally believe "C/C++" is insult to both the languages. :)– DeepuCommented Apr 22, 2013 at 2:22
-
fair enough, I didn't realize it was changing. Maybe it even said that earlier and I missed it. -1 removed. Commented Apr 22, 2013 at 4:20
-
I like the answer of Ed S., but this only works for fixed size arrays and not when the arrays are defined as pointers.
So, the C++ solution where the arrays are defined as pointers:
#include <algorithm>
...
const int bufferSize = 10;
char* origArray, newArray;
std::copy(origArray, origArray + bufferSize, newArray);
Note: No need to deduct buffersize
with 1:
- Copies all elements in the range [first, last) starting from first and proceeding to last - 1
-
1
-
I give here 2 ways of coping array, for C and C++ language. memcpy and copy both ar usable on C++ but copy is not usable for C, you have to use memcpy if you are trying to copy array in 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;
}
-
4
using namespace std;
is a bad practice. Don't ever use it. Instead of cplusplus.com, please use cppreference.com, which includes much better and up-to-date documentation of the standard. Thestdio.h
equivalent in C++ iscstdio
, use that instead. Additionally, the code is fairly non-idiomatic C++. I think it'd be much clearer if you had showcased separate solutions for C and C++.– tambreCommented Sep 2, 2017 at 17:33
Just include the standard library in your code.
#include<algorithm>
Array size will be denoted as n
Your old Array
int oldArray[n]={10,20,30,40,50};
Declare New Array in which you have to copy your old array value
int newArray[n];
Use this
copy_n(oldArray,n,newArray);
in C++11 you may use Copy()
that works for std containers
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;
}
-
It would be a better idea to pull the
std::end
out of the loop, for performance reasons (c1 doesn't change or invalidate iterators during the loop,so it's unnecessary to re-calculate the end).– celtschkCommented Sep 5, 2016 at 17:43
Firstly, because you are switching to C++, vector is recommended to be used instead of traditional array.
Besides, to copy an array or vector, std::copy
is the best choice for you.
Visit this page to get how to use copy function: http://en.cppreference.com/w/cpp/algorithm/copy
Example:
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());
Try this :
- Create an empty array.
- Insert the elements.
- Create a duplicate empty array of the same size.
- Start for
i=0
to i=array length.
5.newarray[i]=oldarray[i]
(only for C++)
C++ program
#include<iostream>
using namespace std;
int main()
{
int initA[100],finA[100],i,size;
cout<<"Input the size of the array : ";
cin>>size;
cout<<"Input the elements of the first array";
for(i=0;i<size;i++)
{
cin>>initA[i];
}
for(i=0;i<size;i++)
{
finA[i]=initA[i];
}
cout<<"The final array is\n";
for(i=0;i<size;i++)
cout<<finA[i]<<" ";
return 0;
}
-
I don't see why you would write a loop manually instead of just using the standard
copy
ormemcpy
methods.– CPlusCommented May 3, 2023 at 20:32
C++ 20
You can use std::ranges::copy
as simple, as std::ranges::copy(a, b);
#include <algorithm> // ranges::copy, ranges::copy_if
#include <iostream> // cout
#include <iterator> // ostream_iterator, begin, end
#include <numeric> // iota
int main()
{
float source[10];
std::iota(std::begin(source), std::end(source), 0);
float destination[10];
std::ranges::copy(source, destination);
std::cout << "destination contains: ";
std::ranges::copy(destination, std::ostream_iterator<float>(std::cout, " "));
std::cout << '\n';
std::cout << "odd numbers in destination are: ";
std::ranges::copy_if(destination, std::ostream_iterator<float>(std::cout, " "),
[](int x) { return (x % 2) == 1; });
std::cout << '\n';
}
-
Found a really interesting thing. if you make the arrays with int arr[num] syntax std::ranges::copy works fine but if you heap allocate with int* arr = new int[num] it throws a really weird error: no instance of overloaded function "std::ranges::_Copy_fn::operator()" matches the argument list Commented May 27 at 18:43
-
1@ThomasBourne in the first case
arr
is the reference to fixed sized array, so it can infer array size from type. In the second casearr
is just a pointer to single int (first element). Commented May 29 at 21:34 -
1@ThomasBourne you can use 2 arg iterator overload (cause pointers are some kind of iterstor), i.e.
std::ranges::copy(source, source + num, destination);
Commented May 29 at 21:45 -
ahhh thank you for this, I didnt realise fundimentally they were different in the way they were stored. That is really interesting and useful thank you mate! Commented May 31 at 8:33
-
@ThomasBourne the difference not in the storage, but in the type of variable. In the first case
arr
is of an array type (int [10]
), in the secondarr
is justint*
(causeoperator new
only returns pointers). In C++ array may implicitly decay to pointer, but they are not same things. Commented Jun 1 at 21:04
It's interesting that while you can easily copy structs in C/C++, the same straightforward approach doesn't work for arrays. An amusing workaround involves casting an array to a struct pointer, making it possible to copy arrays, as demonstrated below:
int a[10] = {1, 2, 3};
int b[10];
{
typedef struct {char _[sizeof(a)];} _;
*(_*)b = *(_*)a;
}
However, this solution may seem unattractive due to its unconventional appearance. To address this, we can encapsulate the operation within a macro:
#include <assert.h>
#include <stdio.h>
#define ARRAY_ASSIGN(x, y) \
{ assert(sizeof(x) == sizeof(y)); \
typedef struct {char _[sizeof(x)];} _; *(_*)(x) = *(_*)(y);\
}
int
main(void)
{
int a[10] = {1, 2, 3};
int b[10];
ARRAY_ASSIGN(b, a); // b = a
for (size_t i = 0; i < sizeof(b)/sizeof(b[0]); ++i) {
printf("%d ", b[i]);
}
printf("\n");
}
🤣🤣🤣
man memmove
andman memcpy
memcpy
, usestd::copy
. If your type has a meaningful copy constructor thenmemcpy
will do the wrong thing.