มีฟังก์ชันคัดลอกอาร์เรย์ใน C / C ++ หรือไม่?

ฉันเป็นโปรแกรมเมอร์ Java ที่เรียนรู้ C / C ++ ฉันจึงรู้ว่า Java มีฟังก์ชันเหมือน System.arraycopy (); เพื่อคัดลอกอาร์เรย์ ฉันสงสัยว่ามีฟังก์ชันใน C หรือ 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

นี่คือเอกสารเกี่ยวกับstd :: array

เนื่องจากคุณขอโซลูชัน 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));

เป็นคนอื่นได้กล่าวถึงใน C memcpyคุณจะใช้ อย่างไรก็ตามโปรดทราบว่านี่เป็นการคัดลอกหน่วยความจำดิบดังนั้นหากโครงสร้างข้อมูลของคุณมีตัวชี้ถึงตัวเองหรือถึงกันตัวชี้ในสำเนาจะยังคงชี้ไปที่วัตถุดั้งเดิม

ใน C ++ คุณยังสามารถใช้memcpyถ้าสมาชิกอาร์เรย์ของคุณเป็น POD (นั่นคือโดยพื้นฐานแล้วประเภทที่คุณสามารถใช้ได้โดยไม่เปลี่ยนแปลงใน C) แต่โดยทั่วไปmemcpyจะไม่ได้รับอนุญาต std::copyในฐานะที่เป็นคนพูดถึงฟังก์ชั่นในการใช้งาน

ต้องบอกว่าใน C ++ คุณไม่ค่อยควรใช้อาร์เรย์ดิบ คุณควรใช้คอนเทนเนอร์มาตรฐานแทน ( std::vectorซึ่งใกล้เคียงที่สุดกับอาร์เรย์ในตัวและฉันคิดว่าใกล้เคียงกับอาร์เรย์ Java มากที่สุด - ใกล้กว่าอาร์เรย์ C ++ ธรรมดาแน่นอน - แต่std::dequeหรือstd::listอาจเหมาะสมกว่าในบางกรณี) หรือถ้าคุณใช้ C ++ 11 std::arrayซึ่งอยู่ใกล้กับอาร์เรย์ในตัวมาก แต่มีค่าความหมายเหมือนกับ C ++ ประเภทอื่น ๆ ทุกประเภทที่ฉันกล่าวถึงที่นี่สามารถคัดลอกได้โดยการมอบหมายงานหรือคัดลอกโครงสร้าง ยิ่งไปกว่านั้นคุณสามารถ "cross-copy" จาก 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;
}

คุณสามารถใช้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การคัดลอกจะเกิดขึ้นราวกับว่ามีการใช้บัฟเฟอร์กลางทำให้ปลายทางและต้นทางทับซ้อนกัน

ใช้memcpyใน C std::copyใน C ++

ฉันชอบคำตอบของ Ed S. แต่ใช้ได้กับอาร์เรย์ขนาดคงที่เท่านั้นและไม่ใช่เมื่ออาร์เรย์ถูกกำหนดให้เป็นพอยน์เตอร์

ดังนั้นโซลูชัน C ++ ที่อาร์เรย์ถูกกำหนดให้เป็นพอยน์เตอร์:

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

หมายเหตุ : ไม่ต้องหักbuffersizeด้วย 1:

1. คัดลอกองค์ประกอบทั้งหมดในช่วง [แรกสุดท้าย) โดยเริ่มจากอันดับแรกและดำเนินการต่อไปจนถึงสุดท้าย - 1

ดู: https://en.cppreference.com/w/cpp/algorithm/copy

ใน C คุณสามารถmemcpyใช้ได้ ใน C ++ ใช้std::copyจาก<algorithm>ส่วนหัว

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

ฉันให้ที่นี่ 2 วิธีในการจัดการอาร์เรย์สำหรับภาษา C และ C ++ memcpyและคัดลอก ar ทั้งสองใช้งานได้บน C ++ แต่สำเนาไม่สามารถใช้กับ C ได้คุณต้องใช้memcpyหากคุณพยายามคัดลอกอาร์เรย์ใน 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;
}

เพียงรวมไลบรารีมาตรฐานไว้ในโค้ดของคุณ

#include<algorithm>

ขนาดอาร์เรย์จะแสดงเป็น n

อาร์เรย์เก่าของคุณ

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

ประกาศ New Array ซึ่งคุณต้องคัดลอกค่าอาร์เรย์เก่าของคุณ

int newArray[n];

ใช้สิ่งนี้

copy_n(oldArray,n,newArray);

ประการแรกเพราะคุณจะเปลี่ยนไปที่ C ++, เวกเตอร์จะแนะนำให้นำมาใช้แทนแบบดั้งเดิมอาร์เรย์ นอกจากนี้ในการคัดลอกอาร์เรย์หรือเวกเตอร์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());