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

Question

我是一名学习C/C++的Java程序员.所以我知道Java有一个类似System.arraycopy()的函数; 复制数组.我想知道C或C++中是否有复制数组的函数.我只能通过使用for循环,指针等找到复制数组的实现.有没有我可以用来复制数组的函数？

Answer 1

既然你要求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));

Answer 2

正如其他人所提到的,在C中你会使用memcpy.但请注意,这会执行原始内存复制,因此如果数据结构具有指向自身或彼此的指针,则副本中的指针仍将指向原始对象.

在C++中,你也可以使用memcpy,如果你的数组成员是POD(即,本质上它也可能用于在C不变类型),但在一般情况下,memcpy将不会被允许.正如其他人提到的,使用的功能是std::copy.

话虽如此,在C++中你很少使用原始数组.相反,您应该使用标准容器之一(std::vector是最接近内置阵列,也是我认为最接近Java数组-比普通的C接近++阵列,确实是- ,但std::deque还是std::list可以在某些情况下更合适)或者,如果您使用C++ 11,std::array它与内置数组非常接近,但与其他C++类型一样具有值语义.我在这里提到的所有类型都可以通过赋值或复制构造进行复制.此外,您可以使用迭代器语法从opne"交叉复制"到另一个(甚至是内置数组).

这给出了可能性的概述(我假设已包含所有相关的标题):

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

Answer 3

从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

这是关于std :: array的文档

Answer 4

你可以用memcpy(),

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

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

如果destination和source重叠,那么你可以使用memmove().

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

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

Answer 5

memcpy在C std::copy中使用,在C++中.

Answer 6

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

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

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

注：无需扣除buffersize1：

1. 复制范围 [first, last) 中的所有元素，从第一个开始并继续到最后一个 - 1

请参阅：https : //en.cppreference.com/w/cpp/algorithm/copy

Answer 7

在C中你可以使用memcpy.在C++中使用std::copy来自<algorithm>标题.

Answer 8

我在这里给出了两种处理数组的方法，分别用于 C 和 C++ 语言。memcpy和copy都可以在 C++ 上使用，但copy不适用于 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;
}

Answer 9

只需在代码中包含标准库即可。

#include<algorithm>

数组大小将表示为n

你的旧数组

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

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

int newArray[n];

用这个

copy_n(oldArray,n,newArray);