114

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

4

12 回答 12

167

既然您要求 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));
于 2013-04-22T01:12:27.543 回答
99

从 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的文档

于 2013-04-22T01:12:48.347 回答
91

正如其他人所提到的，在 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;
}
于 2013-08-18T12:39:41.583 回答
19

memcpy在 C、std::copyC++ 中使用。

于 2013-04-22T01:12:34.910 回答
18

您可以使用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。复制就像使用中间缓冲区一样进行，允许目标和源重叠。

于 2013-04-22T01:09:49.457 回答
13

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

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

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

注：无需扣除buffersize1：

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

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

于 2019-07-18T08:50:30.337 回答
11

在 C 中，您可以使用memcpy. 在 C++std::copy中从头文件中使用<algorithm>。

于 2013-04-22T01:12:53.580 回答
5

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

#include<algorithm>

数组大小将表示为n

你的旧数组

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

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

int newArray[n];

用这个

copy_n(oldArray,n,newArray);
于 2019-05-31T04:47:47.383 回答
3

在 C++11 中，您可以使用Copy()适用于标准容器的

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;
}
于 2014-12-09T19:08:56.357 回答
3

我在这里给出了 2 种处理数组的方法，用于 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;
}
于 2017-09-02T16:59:41.000 回答
2

首先，由于您正在切换到 C++，因此建议使用vector而不是传统的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());
于 2016-12-06T23:04:27.573 回答
1

尝试这个 ：

  1. 创建一个空数组。
  2. 插入元素。
  3. 创建一个相同大小的重复空数组。
  4. 开始为i=0i=数组长度。
    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;
}
于 2021-11-17T15:02:16.450 回答