मैं कच्चे सरणी से std :: वेक्टर में memcpy के बराबर कैसे कर सकता हूं?

Question

मेरे पास एक कक्षा है जिसमें कई अन्य चीजों के साथ एक हस्ताक्षर किए गए चार को पॉइंटर है जो हटा दिया जाता है और किसी अन्य सरणी से कुछ डेटा स्टोर करने के लिए पुनः आवंटित किया जाता है। यह एक समारोह

class MyClass { 
    private: 
     unsigned char* m_Buffer; 
     int m_BufferSize; 
    public: 
     bool SetBuffer(int iSize, const unsigned char* pArray); 
}; 

bool MyClass::SetBuffer(int iSize, const unsigned char* pArray) { 
    bool bOK = false; 
    if (pArray != NULL && iSize > 0) { 
     delete [] m_Buffer; 
     m_Buffer = new unsigned char[iSize]; 
     memcpy(m_Buffer,pArray,iSize); 
     m_BufferSize = iSize; 
     bOK = true; 
     } 
     return bOK; 
    } 

मैं इस कोड पसंद नहीं के साथ किया है, और मैं वास्तव में एक std::vector<unsigned char> साथ सूचक को बदलने के लिए चाहते हैं। मेरा सवाल है, मैं memcpy पहलू कैसे प्रदर्शन करेंगे? अगर मैं अपने फ़ंक्शन के लिए तर्क के रूप में वेक्टर पास कर रहा था, तो मैं इसे इटरेटर्स का उपयोग करके कॉपी कर सकता था, लेकिन मेरे पास पैरामीटर तर्क प्रकार पर कोई नियंत्रण नहीं है इसलिए मैं unsigned char* से फंस गया हूं। क्या इटरेटर का उपयोग करने का कोई तरीका है, या सही आकार में वेक्टर का आकार बदलना और उसके आंतरिक सरणी को एक्सेस करना ताकि मैं अभी भी memcpy के साथ डेटा कॉपी कर सकूं? या इटरेटर का उपयोग कर बेहतर कुछ भी ?? मुझे पता है कि मैं एक लूप और push_back का उपयोग कर सकता हूं लेकिन यह मेरे लिए दर्दनाक रूप से अक्षम है। किसी भी सुझाव आभारी रूप से प्राप्त किया जाएगा।

Answer 1

दरअसल, इटरेटर को पॉइंटर्स से मॉडलिंग किया जाता है और इसलिए एक सरणी के भीतर पॉइंटर्स को RandomAccessIterator अवधारणा को लागू करने के लिए माना जाता है।

इसलिए:

m_buffer.assign(pArray, pArray + Size); 

Answer 2

मैं वास्तव में कच्चे संकेत दिए गए इस तरह से बचने के लिए सलाह देते हैं। मुझे लगता है कि कच्चे पॉइंटर्स के बजाय std :: vectors को प्रबंधित करना बेहतर विचार है।

class MyClass { 
private: 
    std::vector<unsigned char> m_Buffer; 
    // No size member is needed, it is stored in m_Buffer 
public: 
    // No size parameter is needed, it is stored in Array 
    void SetBuffer(const std::vector<unsigned char> &Array); 
}; 

void MyClass::SetBuffer(const std::vector<unsigned char> &Array) { 
    std::copy(Array.begin(), Array.end(), m_Buffer.begin()); 
} 

मान लिया जाये कि एक कच्चे कामयाब MyClass के लिए आप प्रति निर्माणकर्ता और operator = पर इस सूचक का ख्याल रखना होगा (या बजाय इसे से छुटकारा पाने के) के लिए है कि अपने dessing बलों: यदि आपके पास

MyClass::MyClass(const MyClass &Class) { 
    m_BufferSize = Class.m_BufferSize; 
    m_Buffer = new new unsigned char[m_BufferSize]; 
    memcpy(m_Buffer, Class.m_Buffer, m_BufferSize); 
} 

MyClass::operator =(const MyClass &Class) { 
    if (m_Buffer) delete [] m_Buffer; 
    m_BufferSize = Class.m_BufferSize; 
    m_Buffer = new new unsigned char[m_BufferSize]; 
    memcpy(m_Buffer, Class.m_Buffer, m_BufferSize); 
} 

कॉपी कन्स्ट्रक्टर और operator = में MyClass प्रबंधित पॉइंटर्स का ख्याल रखना नहीं है, आप उसी स्मृति को प्रबंधित करने के MyClass के दो उदाहरणों के साथ समाप्त होंगे।