C / C ++ 'da bir diziyi kopyalamak için bir işlev var mı?

Ben C / C ++ öğrenen bir Java programcısıyım. Yani Java'nın System.arraycopy () gibi bir işlevi olduğunu biliyorum; bir diziyi kopyalamak için. Bir diziyi kopyalamak için C veya C ++ 'da bir işlev olup olmadığını merak ediyordum. Sadece for döngüsü, işaretçiler vb. Kullanarak bir diziyi kopyalamak için bir uygulama bulabildim. Bir diziyi kopyalamak için kullanabileceğim bir işlev var mı?

C ++ 11'den beri, dizileri doğrudan şu şekilde kopyalayabilirsiniz std::array:

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

İşte std :: array ile ilgili dokümantasyon

Bir C ++ çözümü istediğiniz için ...

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

Başkalarının da bahsettiği gibi, C'de kullanırsınız memcpy. Bununla birlikte, bunun bir ham bellek kopyası yaptığına dikkat edin, bu nedenle veri yapılarınız kendilerine veya birbirlerine göstericiye sahipse, kopyadaki işaretçiler yine de orijinal nesneleri gösterecektir.

C ++ da kullanabilirsiniz memcpydiziniz üyeleri, (ayrıca C değişmeden kullanmış olabilir, esasen türleri) ama genel olarak POD ise memcpyedecektir değil izin verilebilir. Diğerlerinde belirtildiği gibi, kullanılacak işlev std::copy.

Bunu söyledikten sonra, C ++ 'da nadiren ham dizileri kullanmalısınız. Bunun yerine ya standart konteynerlerin birini kullanmalıdır ( std::vectorbir dizide dahili ve ayrıca Java diziler en yakın düşünmek en yakın - yakın düz C'nin ++ diziler, gerçekten de - ama std::dequeya std::listbazı durumlarda daha uygun olabilir) veya std::arrayyerleşik dizilere çok yakın olan, ancak diğer C ++ türleri gibi değer semantiği olan C ++ 11 kullanıyorsanız . Burada bahsettiğim tüm türler ödev veya kopya oluşturma yoluyla kopyalanabilir. Dahası, yineleyici sözdizimini kullanarak opne'den diğerine (ve hatta yerleşik bir diziden) "çapraz kopyalama" yapabilirsiniz.

Bu, olasılıklara genel bir bakış sağlar (ilgili tüm başlıkların dahil edildiğini varsayıyorum):

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

Sen kullanabilirsiniz memcpy(),

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

memcpy()numbaytların değerlerini, ile gösterilen konumdan sourcedoğrudan işaret ettiği bellek bloğuna kopyalar destination.

Eğer destinationve sourceörtüşme, o zaman kullanabilirsiniz memmove().

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

memmove()numbaytların değerlerini, ile gösterilen konumdan işaret ettiği sourcebellek bloğuna kopyalar destination. Kopyalama, bir ara tampon kullanılmış gibi gerçekleşir ve hedef ve kaynağın çakışmasına izin verir.

memcpyC, std::copyC ++ 'da kullanın .

Ed S.'nin cevabını beğendim, ancak bu yalnızca sabit boyutlu diziler için işe yarıyor ve diziler işaretçi olarak tanımlandığında değil.

Yani dizilerin işaretçiler olarak tanımlandığı C ++ çözümü:

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

Not : buffersize1 ile düşmeye gerek yok :

1. [İlk, son) aralıktaki tüm öğeleri ilkinden başlayıp sonuncuya kadar kopyalar - 1

Bakınız: https://en.cppreference.com/w/cpp/algorithm/copy

C'de kullanabilirsiniz memcpy. C ++ std::copy'da <algorithm>başlıktan kullanın .

C ++ 11'de Copy()std kapsayıcılar için çalışan kullanabilirsiniz

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

Burada C ve C ++ dili için dizi başa çıkmanın 2 yolunu veriyorum. memcpy ve copy, her ikisi de C ++ 'da kullanılabilir, ancak copy C için kullanılamaz, C dizisini kopyalamaya çalışıyorsanız memcpy kullanmanız gerekir .

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

Standart kitaplığı kodunuza eklemeniz yeterlidir.

#include<algorithm>

Dizi boyutu şu şekilde belirtilecektir: n

Eski Diziniz

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

Eski dizi değerinizi kopyalamanız gereken Yeni Dizi Bildirin

int newArray[n];

Bunu kullan

copy_n(oldArray,n,newArray);

Öncelikle, C ++ 'ya geçtiğiniz için geleneksel dizi yerine vektör kullanılması önerilir . Ayrıca, bir dizi veya vektörü kopyalamak std::copysizin için en iyi seçimdir.

Kopyalama işlevini nasıl kullanacağınızı öğrenmek için bu sayfayı ziyaret edin: http://en.cppreference.com/w/cpp/algorithm/copy

Misal:

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