बाइनरी फ़ाइल सी ++

Question

पर बिट डेटा आउटपुट करना मैं एक संपीड़न प्रोग्राम लिख रहा हूं, और सी ++ का उपयोग करके बाइनरी फ़ाइल में थोड़ा डेटा लिखने की आवश्यकता है। यदि कोई भी लिखने के वक्तव्य, या सलाह के साथ एक वेबसाइट पर सलाह दे सकता है, तो मैं बहुत आभारी रहूंगा।

क्षमा करें अगर यह एक साधारण या भ्रमित प्रश्न है, तो मैं वेब पर जवाब खोजने के लिए संघर्ष कर रहा हूं।

Answer 1

बिट्स को पूरे बाइट्स में एकत्र करें, जैसे एक हस्ताक्षरित char या std :: बिटसेट (जहां बिटसेट आकार CHAR_BIT का एक बहु है), फिर एक समय में पूरे बाइट्स लिखें। कंप्यूटर "बिट्स के साथ सौदा", लेकिन उपलब्ध अमूर्त - विशेष रूप से आईओ के लिए - यह है कि आप एक प्रोग्रामर के रूप में, व्यक्तिगत बाइट्स से निपटते हैं। बिट बिट मैनिपुलेशन का उपयोग विशिष्ट बिट्स को टॉगल करने के लिए किया जा सकता है, लेकिन आप हमेशा बाइट-साइज्ड ऑब्जेक्ट्स को संभालने वाले होते हैं।

आउटपुट के अंत में, यदि आपके पास कोई संपूर्ण बाइट नहीं है, तो आपको यह तय करना होगा कि उसे कैसे संग्रहीत किया जाना चाहिए। Iostreams और stdio दोनों क्रमशः ostream :: लिखने और fwrite का उपयोग कर unformatted डेटा लिख ​​सकते हैं।

एक सिंगल चार या बिटसेट < 8> (8 CHAR_BIT के लिए सबसे आम मान होने के बजाय), आप बड़े ब्लॉक आकार का उपयोग करने पर विचार कर सकते हैं, जैसे 4-32, या अधिक, वर्ण या समकक्ष आकार का बिटसेट।

Answer 2

द्विआधारी लिखने के लिए, जिस चाल को मैंने सबसे उपयोगी पाया है, वह सभी बाइनरी को स्मृति में एक सरणी के रूप में स्टोर करना है और फिर इसे हार्ड ड्राइव पर ले जाना है। एक समय में थोड़ा सा करना, या एक समय में एक बाइट करना, या एक समय में एक लंबे समय तक हस्ताक्षरित एक लंबे समय तक एक सरणी में संग्रहीत सभी डेटा और "fwrite()" के एक उदाहरण का उपयोग करके इसे स्टोर करने के लिए तेज़ नहीं है हार्ड ड्राइव।

size_t fwrite (कॉन्स शून्य * पीआरटी, आकार_टी आकार, आकार_टी गिनती, फ़ाइल * स्ट्रीम);

रेफरी: http://www.cplusplus.com/reference/clibrary/cstdio/fwrite/

अंग्रेजी में:।

fwrite ([संग्रहीत डेटा के * सरणी], [सरणी वस्तु की बाइट में आकार अहस्ताक्षरित वर्ण के लिए -> 1, अहस्ताक्षरित लंबे देशांतर के लिए -> 8 ], [सरणी में उदाहरणों की संख्या], [फ़ाइल *])

हमेशा सफलता के सत्यापन के लिए अपने रिटर्न की जांच करें!

इसके अतिरिक्त, एक तर्क दिया जा सकता है कि ऑब्जेक्ट प्रकार जितना संभव हो उतना बड़ा हो (जाने के लिए सबसे तेज़ तरीका है ([लंबे समय तक हस्ताक्षर किए गए]> [char])। जबकि मुझे "fwrite()" के पीछे कोडिंग में नहीं पता है, मुझे लगता है कि आपके कोड में इस्तेमाल होने वाली प्राकृतिक वस्तु से [अप्रमाणित लंबे समय तक] में परिवर्तित करने का समय लगता है, "fwrite() से अधिक लेखन के साथ संयुक्त होने में अधिक समय लगेगा "आपके पास जो कुछ है उसके कारण बना रहा है।

वापस जब मैं हफमैन कोडिंग सीख रहा था, मुझे यह महसूस करने में कुछ घंटे लगे कि [char] और [unsigned char] के बीच कोई अंतर था। इस विधि के लिए नोटिस कि आपको शुद्ध बाइनरी को स्टोर करने के लिए हमेशा हस्ताक्षरित चर का उपयोग करना चाहिए।

Answer 3

नीचे वर्ग आप लिख सकते हैं और पढ़ थोड़ा करके बिट

class bitChar{ 
public: 
    unsigned char* c; 
    int shift_count; 
    string BITS; 

    bitChar() 
    { 
     shift_count = 0; 
     c = (unsigned char*)calloc(1, sizeof(char)); 
    } 

    string readByBits(ifstream& inf) 
    { 
     string s =""; 
     char buffer[1]; 
     while (inf.read (buffer, 1)) 
     { 
      s += getBits(*buffer); 
     } 
     return s; 
    } 

    void setBITS(string X) 
    { 
     BITS = X; 
    } 

    int insertBits(ofstream& outf) 
    { 
     int total = 0; 

     while(BITS.length()) 
     { 
      if(BITS[0] == '1') 
       *c |= 1; 
      *c <<= 1; 
      ++shift_count; 
      ++total; 
      BITS.erase(0, 1); 

      if(shift_count == 7) 
      { 
       if(BITS.size()>0) 
       { 
        if(BITS[0] == '1') 
         *c |= 1; 
        ++total; 
        BITS.erase(0, 1); 
       } 

       writeBits(outf); 
       shift_count = 0; 
       free(c); 
       c = (unsigned char*)calloc(1, sizeof(char)); 
      } 
     } 

     if(shift_count > 0) 
     { 
      *c <<= (7 - shift_count); 
      writeBits(outf); 
      free(c); 
      c = (unsigned char*)calloc(1, sizeof(char)); 
     } 
     outf.close(); 
     return total; 
    } 

    string getBits(unsigned char X) 
    { 
     stringstream itoa; 
     for(unsigned s = 7; s > 0 ; s--) 
     { 
      itoa << ((X >> s) & 1); 
     } 

     itoa << (X&1) ; 
     return itoa.str(); 
    } 

    void writeBits(ofstream& outf) 
    { 
     outf << *c; 
    } 

    ~bitChar() 
    { 
     if(c) 
      free(c); 
    } 
}; 

द्वारा लिए example

#include <iostream> 
#include <sstream> 
#include <fstream> 
#include <string> 
#include <stdlib.h> 
using namespace std; 


int main() 
{ 
    ofstream outf("Sample.dat"); 
    ifstream inf("Sample.dat"); 

    string enCoded = "101000001010101010"; 

    //write to file 
    cout << enCoded << endl ; //print 101000001010101010 
    bitChar bchar; 
    bchar.setBITS(enCoded); 
    bchar.insertBits(outf); 

    //read from file 
    string decoded =bchar.readByBits(inf); 
    cout << decoded << endl ; //print 101000001010101010000000 
    return 0; 
}