सी ++ के साथ 4 जीबी फ़ाइल में डेटा कैसे लिखें?

Question

मैं एक बड़ी फाइल लिखने की कोशिश कर रहा हूं, लेकिन एक समस्या में भाग गया।

मैं लिखने के लिए जगह खोजने के लिए लंबे समय तक उपयोग करता हूं, लेकिन 4,2 जीबी से अधिक फ़ाइल नहीं लिख सकता। मैं क्या भूल गया?

अधिक विवरण: मैं 4Gb-फ़ाइल को खोलने:

ifstream ifs(db_name.c_str(), ios_base::binary); 
if (!ifs) 
    throw Bad_archive(); 
ifs.read(as_bytes(seg_size), sizeof(int)); 
ifs.read(as_bytes(last_idx), sizeof(int)); 
ifs.read(as_bytes(free_segs), sizeof(int)); 
if (free_segs > 0) 
{ 
    long long seek_g = 3 * sizeof(int) + (long long)last_idx * seg_size; 
    ifs.seekg(seek_g, ios_base::beg); 
    for (int i = 0; i < free_segs; i++) 
    { 
     int tmp = 0; 
     ifs.read(as_bytes(tmp), sizeof(int)); 
     free_spaces.push_back(tmp); 
    } 
} 
ifs.close(); 

उसके बाद, मैं 400MB-फ़ाइल है, जो मैं db में जोड़ना चाहते हैं पढ़ें। और लिखने (यहाँ शॉर्ट कोड है):

// write object 
ofstream ofs(db_name.c_str(), ios_base::binary | ios_base::in | ios_base::ate); 
for (int i = 0; ; i++) 
{ 
    // set stream position 
    long long write_position = sizeof(int) * 3; 

    ... 

    write_position += (long long) seg_size * last_idx; 
    ofs.seekp(write_position, ios::beg); 

      ... 

    // write sizeof object 
    if (i == 0) 
     ofs.write(as_bytes(object_size), sizeof(object_size)); 
    else 
    { 
     int null = 0; 
     ofs.write(as_bytes(null), sizeof(null)); 
    } 

    // write data 
    for (int j = 0; j < (seg_size - sizeof(int) * 2); j++) 
    { 
     ofs.write(as_bytes(obj_content[j + i * (seg_size - sizeof(int) * 2)]), 
     sizeof(char)); 

    } 
    if (write_new_seg) 
     last_idx++; 

    ... 

    ofs.write(as_bytes(cont_seg), sizeof(cont_seg)); 
} 
ofs.close(); 

उसके बाद, मैं db जानकारी को बचाने:

if (last_idx == 0) 
{ 
    ofstream ofs(db_name.c_str()); 
    ofs.close(); 
} 
ofstream ofs(db_name.c_str(), ios_base::binary | ios_base::in | 
      ios_base::out | ios_base::ate); 
long long seek_p = 0; 
ofs.seekp(seek_p, ios_base::beg); 
ofs.write(as_bytes(seg_size), sizeof(seg_size)); 
ofs.write(as_bytes(last_idx), sizeof(last_idx)); 
ofs.write(as_bytes(free_segs), sizeof(free_segs)); 
ofs.close(); 

लेकिन इस कोड काम करता है:

ofstream ofs2("huge2"); 
ofs2.close(); 
ofstream ofs("huge2", ios_base::in | ios_base::ate); 
long long sp = 10000000000; 
ofs.seekp(10000000000, ios_base::beg); 

ofs.write(as_bytes(sp), sizeof(sp)); 

ofs.close(); 

Answer 1

fseeko64 (Filename, 0, SEEK_END); 
    long size = ftello64 (Filename); 
    fclose (Filename); 

बड़ी फ़ाइलों तक पहुँचने के लिए, fseek नहीं किया जा सकता है, बजाय fseeko64 के लिए जाना है();

Answer 2

कई filesystems फ़ाइलों का समर्थन नहीं करते 4 जीबी से बड़ा इसके अतिरिक्त, आपको यह मानना ​​चाहिए कि आपके int प्रकार में ऐसी सीमा हो सकती है जो 2^32 पर समाप्त हो, यानी 4.2 9 4 9 7e + 09।

Answer 3

Win32 पर _lseeki64() नामक एक फ़ंक्शन है, और lseek64() पर * nix। हालांकि, iostream लाइब्रेरी उन्हें सीधे लपेटती नहीं है, आपको फ़ाइल डिस्क्रिप्टर को किसी भी तरह से पुनर्प्राप्त करना होगा, और बफरिंग के बारे में कुछ करना होगा।

Answer 4

लिनक्स यहाँ के लिए एक अच्छी सारांश है: RedHat लक्ष्यीकरण RHEL से

http://www.suse.de/~aj/linux_lfs.html

और अधिक विशिष्ट विस्तार, इन समस्याओं 64-बिट फ़ाइलों आकार तक पहुँचने 32-बिट अनुप्रयोगों के लिए आम तौर पर कर रहे हैं।

http://people.redhat.com/berrange/notes/largefile.html

विकिपीडिया वास्तव में Large File Support पर एक artile लेकिन वास्तव में है कि जानकारीपूर्ण नहीं है।