Có một chức năng để sao chép một mảng trong C / C ++ không?

Tôi là một lập trình viên Java đang học C / C ++. Vì vậy, tôi biết rằng Java có một chức năng như System.arraycopy (); để sao chép một mảng. Tôi đã tự hỏi nếu có một hàm trong C hoặc C ++ để sao chép một mảng. Tôi chỉ có thể tìm thấy triển khai để sao chép một mảng bằng cách sử dụng vòng lặp for, con trỏ, v.v. Có chức năng nào mà tôi có thể sử dụng để sao chép một mảng không?

Kể từ C ++ 11, bạn có thể sao chép mảng trực tiếp với std::array:

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

Đây là tài liệu về std :: array

Vì bạn đã yêu cầu giải pháp 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));

Như những người khác đã đề cập, trong C bạn sẽ sử dụng memcpy. Tuy nhiên, lưu ý rằng điều này thực hiện một bản sao bộ nhớ thô, vì vậy nếu cấu trúc dữ liệu của bạn có con trỏ tới chính chúng hoặc với nhau, các con trỏ trong bản sao sẽ vẫn trỏ đến các đối tượng gốc.

Trong C ++, bạn cũng có thể sử dụng memcpynếu các thành viên mảng của bạn là POD (nghĩa là về cơ bản các kiểu mà bạn cũng có thể sử dụng không thay đổi trong C), nhưng nói chung, memcpysẽ không được phép. Như những người khác đã đề cập, chức năng sử dụng là std::copy.

Phải nói rằng, trong C ++, bạn hiếm khi nên sử dụng mảng thô. Thay vào đó, bạn nên sử dụng một trong các vùng chứa tiêu chuẩn ( std::vectorlà vùng gần nhất với mảng tích hợp sẵn và tôi cũng nghĩ là gần nhất với mảng Java - thực sự gần hơn so với mảng C ++ thuần túy - nhưng std::dequehoặc std::listcó thể thích hợp hơn trong một số trường hợp) hoặc, nếu bạn sử dụng C ++ 11, std::arrayrất gần với các mảng dựng sẵn, nhưng có ngữ nghĩa giá trị như các loại C ++ khác. Tất cả các loại tôi đề cập ở đây có thể được sao chép bằng cách phân công hoặc sao chép xây dựng. Hơn nữa, bạn có thể "sao chép chéo" từ opne này sang opne khác (và thậm chí từ một mảng dựng sẵn) bằng cách sử dụng cú pháp trình lặp.

Điều này cung cấp một cái nhìn tổng quan về các khả năng (tôi cho rằng tất cả các tiêu đề liên quan đã được bao gồm):

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

Bạn có thể sử dụng memcpy(),

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

memcpy()sao chép các giá trị của numbyte từ vị trí được trỏ đến sourcetrực tiếp vào khối bộ nhớ được trỏ tới destination.

Nếu destinationvà sourcechồng chéo, sau đó bạn có thể sử dụng memmove().

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

memmove()sao chép các giá trị của numbyte từ vị trí được trỏ sourceđến vào khối bộ nhớ được trỏ bởi destination. Việc sao chép diễn ra như thể một bộ đệm trung gian được sử dụng, cho phép đích và nguồn chồng lên nhau.

Sử dụng memcpytrong C, std::copytrong C ++.

Tôi thích câu trả lời của Ed S., nhưng điều này chỉ hoạt động đối với các mảng có kích thước cố định chứ không phải khi các mảng được xác định là con trỏ.

Vì vậy, giải pháp C ++ trong đó các mảng được định nghĩa là con trỏ:

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

Lưu ý : Không cần khấu trừ buffersizevới 1:

1. Sao chép tất cả các phần tử trong phạm vi [đầu tiên, cuối cùng) bắt đầu từ đầu tiên và tiếp tục đến cuối cùng - 1

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

Trong C bạn có thể sử dụng memcpy. Trong C ++ sử dụng std::copytừ <algorithm>tiêu đề.

trong C ++ 11, bạn có thể sử dụng Copy()nó hoạt động cho các vùng chứa std

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

Tôi đưa ra đây 2 cách đối phó mảng, cho ngôn ngữ C và C ++. memcpy và sao chép cả ar đều có thể sử dụng được trên C ++ nhưng bản sao không sử dụng được đối với C, bạn phải sử dụng memcpy nếu bạn đang cố gắng sao chép mảng trong 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;
}

Chỉ cần đưa thư viện chuẩn vào mã của bạn.

#include<algorithm>

Kích thước mảng sẽ được ký hiệu là n

Mảng cũ của bạn

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

Khai báo mảng mới trong đó bạn phải sao chép giá trị mảng cũ của mình

int newArray[n];

Dùng cái này

copy_n(oldArray,n,newArray);

Thứ nhất, vì bạn đang chuyển sang C ++, nên sử dụng vector thay vì mảng truyền thống . Bên cạnh đó, để sao chép một mảng hoặc vector, std::copylà sự lựa chọn tốt nhất cho bạn.

Truy cập trang này để biết cách sử dụng chức năng sao chép: http://en.cppreference.com/w/cpp/algorithm/copy

Thí dụ:

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