क्या C / C ++ में किसी सरणी को कॉपी करने के लिए कोई फ़ंक्शन है?

Question 1

मैं एक जावा प्रोग्रामर हूं जो C / C ++ सीख रहा है। तो मुझे पता है कि जावा में System.arraycopy () जैसा एक फ़ंक्शन है; किसी सरणी को कॉपी करने के लिए। मैं सोच रहा था कि किसी सरणी को कॉपी करने के लिए C या C ++ में कोई फंक्शन है या नहीं। मैं केवल लूप, पॉइंटर्स इत्यादि का उपयोग करके किसी सरणी को कॉपी करने के लिए कार्यान्वयन खोजने में सक्षम था। वहाँ एक समारोह है कि मैं एक सरणी की नकल करने के लिए उपयोग कर सकते हैं?

Question 2

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 के बारे में प्रलेखन है

Question 3

चूंकि आपने सी ++ समाधान के लिए कहा था ...

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

Question 4

जैसा कि दूसरों ने उल्लेख किया है, सी में आप उपयोग करेंगे memcpy । ध्यान दें कि यह एक कच्ची मेमोरी कॉपी करता है, इसलिए यदि आपकी डेटा संरचनाएं खुद को या एक-दूसरे को इंगित करती हैं, तो कॉपी में पॉइंटर्स अभी भी मूल ऑब्जेक्ट्स को इंगित करेंगे।

C ++ में आप भी उपयोग कर सकते हैं memcpyयदि आपके सरणी सदस्यों पॉड (है कि अनिवार्य रूप से प्रकार है जो आप भी सी में कोई बदलाव नहीं इस्तेमाल किया जा सकता था), लेकिन सामान्य रूप में, कर रहे हैं memcpyजाएगा नहीं की अनुमति दी जाए। जैसा कि दूसरों ने उल्लेख किया है, उपयोग करने का कार्य हैstd::copy ।

कहा जाता है कि, C ++ में आपको शायद ही कभी कच्चे सरणियों का उपयोग करना चाहिए। इसके बजाय आपको या तो मानक कंटेनरों में से एक का उपयोग करना चाहिए ( std::vectorएक अंतर्निहित सरणी के सबसे करीब है, और मुझे यह भी लगता है कि जावा सरणियों के सबसे करीब - सादे सी ++ सरणियों की तुलना में वास्तव में - लेकिन, std::dequeया std::listकुछ मामलों में अधिक उपयुक्त हो सकता है) या, यदि आप C ++ 11 का उपयोग करते हैं,std::array जो बिल्ट-इन सरणियों के बहुत करीब है, लेकिन अन्य C ++ प्रकारों जैसे मूल्य शब्दार्थों के साथ। मेरे द्वारा उल्लिखित सभी प्रकारों को असाइनमेंट या कॉपी निर्माण द्वारा कॉपी किया जा सकता है। इसके अलावा, आप itter सिंटैक्स का उपयोग करके 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;
}

Question 5

आप का उपयोग कर सकते हैं 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। नकल करना ऐसा लगता है जैसे कि एक मध्यवर्ती बफर का उपयोग किया गया था, जो गंतव्य और स्रोत को ओवरलैप करने की अनुमति देता है।

Question 6

memcpyC में, std::copyC ++ में उपयोग करें ।

Question 7

मुझे एड एस का उत्तर पसंद है, लेकिन यह केवल निश्चित आकार के सरणियों के लिए काम करता है, न कि जब सरणियों को संकेत के रूप में परिभाषित किया जाता है।

तो, C ++ समाधान जहां सरणियों को संकेत के रूप में परिभाषित किया गया है:

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

नोट : buffersize1 के साथ कटौती करने की आवश्यकता नहीं है :

श्रेणी के सभी तत्वों को [पहले, अंतिम) पहले से शुरू करके अंतिम -१ तक ले जाना

देखें: https://en.cppreference.com/w/cpp/algorithm/copy

Question 8

C में आप उपयोग कर सकते हैं memcpy। C ++ std::copyमें <algorithm>हैडर से उपयोग करें ।

Question 9

C ++ 11 में आप Copy()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;
}

Question 10

मैं यहाँ C और C ++ भाषा के लिए, सरणी के 2 तरीके देता हूँ। memcpy और कॉपी दोनों सी पर प्रयोग करने योग्य गिरफ्तारी ++ लेकिन प्रति सी के लिए प्रयोग करने योग्य नहीं है, आप उपयोग करने के लिए है 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;
}

Question 11

बस अपने कोड में मानक पुस्तकालय शामिल करें।

#include<algorithm>

सरणी आकार के रूप में चिह्नित किया जाएगा n

आपका पुराना ऐरे

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

नई ऐरे की घोषणा करें जिसमें आपको अपने पुराने ऐरे मूल्य को कॉपी करना होगा

int newArray[n];

इसे इस्तेमाल करो

copy_n(oldArray,n,newArray);

Question 12

सबसे पहले, क्योंकि आप 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());