संरचना या कक्षा

Question

में स्मार्ट पॉइंटर्स का उपयोग करके मैंने एक फ़ंक्शन लिखा है जो फ़ाइल से बाइट लोड करता है और एक फ़ाइलडेटा स्ट्रक्चर देता है जिसमें बाइट बफर और बफर की लंबाई होती है।

मैं चाहता हूं कि बफर को जितना जल्दी उपभोग किया जाए और स्कोप से बाहर फेंक दिया जाए।

मुझे विभिन्न कास्टिंग त्रुटियों के कारण संकलन करने में समस्या हो रही है। साथ ही, मुझे यकीन नहीं है कि बफर को कॉपी करने के बजाए सही ढंग से स्थानांतरित किया जा रहा है या नहीं। मुझे फ़ाइलडेटा स्ट्रक्चर की प्रतिलिपि नहीं है, क्योंकि यह शायद 16 बाइट्स है।

सामान्य रूप से, आप कक्षा पॉइंटर्स के रूप में स्मार्ट पॉइंटर्स का उपयोग कैसे करते हैं? क्या वह कुछ भी है जो आप करेंगे?

यह एक घबराहट सवाल है, मुझे पता है, लेकिन चूंकि मुझे सामान्य रूप से स्मार्ट पॉइंटर्स के साथ कुछ वैचारिक कठिनाइयों का सामना करना पड़ रहा है, इसलिए मुझे आशा है कि यह उदाहरण मुझे सही दिशा में मदद करेगा।

यहाँ मैं अब तक क्या मिल गया है:

struct FileData 
{ 
    unique_ptr<char[]> buf; 
    unsigned int len; 
}; 

FileData LoadFile(string filename) 
{ 
    ifstream str; 
    str.open(filename, ios::binary); 

    str.seekg(0, ios::end); 
    auto len = str.tellg(); 
    str.seekg(0, ios::beg); 

    char* buf = new char[len]; 

    str.read(buf, len); 
    str.close(); 

    FileData d = { unique_ptr<char[]>(buf), len }; 

    return d; 
} 

संपादित करें: कुछ लोगों के बाद से, त्रुटि संदेश है कि मैं इस वर्तमान कोड के साथ मिल के बारे में उत्सुक हैं यहाँ यह है:

error C2248: 'std::unique_ptr<_Ty>::unique_ptr' : cannot access private member declared in class 'std::unique_ptr<_Ty>' 

Answer 1

आपका कोड, ठीक है एक छोटी सी विस्तार के लिए छोड़कर:

struct FileData 
{ 
    unique_ptr<char[]> buf; 
    <del>unsigned int</del> <ins>streamoff</ins> len; 
}; 

कारण यह आप के लिए संकलन नहीं है कि आपके संकलक कि है अभी तक विशेष चाल सदस्यों की स्वचालित पीढ़ी को लागू नहीं करता है। एक पूरी तरह से सी ++ 11 अनुरूप संकलक में अपने FileData कैसा व्यवहार करेंगे, जैसे कि:

struct FileData 
{ 
    unique_ptr<char[]> buf; 
    streamoff len; 

    FileData(FileData&&) = default; 
    FileData& operator=(FileData&&) = default; 
    FileData(const FileData&) = delete; 
    FileData& operator=(const FileData&) = delete; 
    ~FileData() = default; 
}; 

डिफॉल्ट की चाल निर्माता बस निर्माणों प्रत्येक सदस्य (डिफॉल्ट की चाल कार्य के लिए और इसी तरह) के लिए कदम।

dLoadFile से लौटने पर, एक निहित कदम होता है जो निहित रूप से डिफॉल्ट चालक कन्स्ट्रक्टर से जुड़ जाएगा।

vector<char> या string का उपयोग अन्य लोगों ने सुझाव दिया है कि यह भी काम करेगा। लेकिन सी ++ 11 के संबंध में आपके कोड में कुछ भी गलत नहीं है।

ओह, मैं यह इतना की तरह परिवर्तन कर सकता है:

:

FileData LoadFile(string filename) 
{ 
    ifstream str; 
    str.open(filename, ios::binary); 

    str.seekg(0, ios::end); 
    auto len = str.tellg(); 
    str.seekg(0, ios::beg); 

    FileData d = {unique_ptr<char[]>(new char[len]), len}; 

    str.read(d.buf.get(), d.len); 
    str.close(); 

    return d; 
} 

आप स्पष्ट रूप से FileData चाल सदस्यों परिभाषित करने की जरूरत है, यह की तरह दिखना चाहिए: मैं अपने संसाधनों को जल्दी से जल्दी स्वामित्व प्राप्त करना

struct FileData 
{ 
    unique_ptr<char[]> buf; 
    streamoff len; 

    FileData(FileData&& f) 
     : buf(std::move(f.buf)), 
      len(f.len) 
     { 
      f.len = 0; 
     } 

    FileData& operator=(FileData&& f) 
    { 
     buf = std::move(f.buf); 
     len = f.len; 
     f.len = 0; 
     return *this; 
    } 
}; 

ओह, जो मुझे एक और बिंदु पर लाता है। डिफ़ॉल्ट स्थानांतरित सदस्य बिल्कुल सही नहीं हैं क्योंकि वे स्रोत में len से 0 सेट नहीं करते हैं। यह आपके दस्तावेज़ पर निर्भर करता है अगर यह एक बग है या नहीं। ~FileData() को बफर की लंबाई को दर्शाने के लिए len की आवश्यकता नहीं है। लेकिन अन्य ग्राहक हो सकता है। यदि आप FileData से एक विश्वसनीय len नहीं रखते हैं, तो डिफ़ॉल्ट स्थानांतरित सदस्य ठीक हैं, अन्यथा वे नहीं हैं।

Answer 2

मैं शायद एक std:::unique_ptr<char[]> के बजाय एक std::vector का प्रयोग करेंगे, अगर आप std::vector प्रतिलिपि बनाई जा रही कोई आपत्ति नहीं है तुम वापस कब FileData:

0,123,

struct FileData 
{ 
    vector<char> buf; 
}; 

FileData LoadFile(string filename) 
{ 
    ifstream str; 
    str.open(filename, ios::binary); 

    str.seekg(0, ios::end); 
    auto len = str.tellg(); 
    str.seekg(0, ios::beg); 

    FileData d; 
    d.buf.resize(len); 

    str.read(&(d.buf)[0], len); 
    str.close(); 

    return d; 
} 

वैकल्पिक रूप से, नकल से बचने के लिए, फोन करने वाले एक वापसी मान के बजाय एक समारोह पैरामीटर के रूप में एक FileData में पारित कर सकते हैं:

struct FileData 
{ 
    vector<char> buf; 
}; 

void LoadFile(string filename, FileData &data) 
{ 
    ifstream str; 
    str.open(filename, ios::binary); 

    str.seekg(0, ios::end); 
    auto len = str.tellg(); 
    str.seekg(0, ios::beg); 

    data.buf.resize(len); 

    str.read(&(data.buf)[0], len); 
    str.close(); 
} 

Answer 3

कैसे बफर के रूप में std :: स्ट्रिंग का उपयोग के बारे में। यह सब व्यवहार आप चाहते है:

• संदर्भ गिना बजाय कॉपी किया
• क्षेत्र से बाहर एक बार गायब हो जाता है
• मनमाने ढंग से बाइट्स की एक मनमाना राशि

लोग नीचे इस मतदान करेंगे क्योंकि पकड़ अपने स्ट्रिंग के मूल उद्देश्य का उपयोग नहीं; शायद एक वर्ग निकाले जाते हैं (या लपेट) और इसे 'बफ़र'