在 C/C + + 中是否有一个复制数组的函数？

你可以用 memcpy(),

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

memcpy()将 num字节的值从 source指定的位置直接复制到 destination指定的内存块。

If the destination and source overlap, then you can use memmove().

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

memmove()将 num字节的值从 source指定的位置复制到 destination指定的内存块。复制就像使用中间缓冲区一样，允许目标和源重叠。

既然你要求 C + + 解决方案。

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

Use memcpy in C, std::copy in C++.

由于 C + + 11，您可以直接使用 std::array复制数组:

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

下面是关于 数组的文档

在 C 语言中可以使用 memcpy。在 C + + 中可以使用 <algorithm>头中的 std::copy。

正如其他人所提到的，在 C 语言中您将使用 memcpy。但是请注意，这是一个原始内存复制，所以如果您的数据结构有指向它们自己或彼此的指针，那么复制中的指针仍然指向原始对象。

在 C + + 中，如果你的数组成员是 POD，你也可以使用 memcpy(也就是说，本质上的类型，你也可以在 C 中使用不变) ，但是一般来说，memcpy是允许使用 没有的。正如其他人提到的，要使用的函数是 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.

这给出了可能性的概述(我假设所有相关的标题都包括在内) :

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

首先，因为要切换到 C + + ，所以建议使用 矢量代替传统的 array。 此外，要复制数组或向量，std::copy是最好的选择。

访问这个页面可以了解如何使用复制函数: http://en.cppreference.com/w/cpp/algorithm/copy

例如:

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

我在这里给出两种应对数组的方法，用于 C 和 C + + 语言。Memcpy和 收到都可以在 C + + 中使用，但是 收到不能在 C 中使用，如果你想在 C 中复制数组，你必须使用 Memcpy。

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

Just include the standard library in your code.

#include<algorithm>

数组大小将表示为 n

你的老数组

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

声明新数组，必须在其中复制旧数组值

int newArray[n];

用这个

copy_n(oldArray,n,newArray);

我喜欢 Ed S 的答案，但这只适用于固定大小的数组，而不适用于将数组定义为指针的情况。

因此，C + + 解决方案将数组定义为指针:

#include<algorithm>
...
const int bufferSize = 10;
char* origArray, newArray;
std::copy(origArray, origArray + bufferSize, newArray);

注 : 不需要扣除 buffersize与1:

1. 复制范围[ first，last ]中从 first 开始到 last-1的所有元素

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

试试这个:

1. 创建一个空数组。
2. 插入元素。
3. Create a duplicate empty array of the same size.
4. 从 i=0开始到 i = 数组长度。
   5. newarray[i]=oldarray[i](只适用于 C + +)

C + + 程序

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