Binär Char Array in Stringstream und Pop aus dem Puffer

Question

Ich habe 20byte binäre Char-Array. Ich möchte in 3 Teile teilen: 4byte, 8byte, 8byte. Ich habe es wie folgt implementiert. Es funktioniert, aber es scheint, ich könnte Puffer-Stream verwenden. Ich möchte wissen, wie man es benutzt. Jetzt

void main() 
{ 
    // _data is 20byte binary char array. 0000000000000000000000000000000000000000000001111001110001111111001110000010110000001011101101000000000000000000000000000000000000000000000000000000000000000001 

    // strA (4 byte) 
    string strA; 
    for (std::size_t i = 0; i < 4; ++i) { 
     strA += bitset<8>(_data.c_str()[i]).to_string(); 
    } 

    cout << strA << endl; // 00000000000000000000000000000000 

    // strB (8 byte) 
    string strB; 
    for (std::size_t i = 4; i < 12; ++i) { 
     strB += bitset<8>(_data.c_str()[i]).to_string(); 
    } 

    cout << strB << endl; // 0000000000000111100111000111111100111000001011000000101110110100 

    // strC (8 byte) 
    string strC; 
    for (std::size_t i = 12; i < 20; ++i) { 
     strC += bitset<8>(_data.c_str()[i]).to_string(); 
    } 

    cout << strC << endl; // 0000000000000000000000000000000000000000000000000000000000000001 
} 

Erwartung

Ich möchte wie diese implementieren.

void main() 
{ 
    stringstream ss = _data; 
    strA = ss.pop(4); 
    strB = ss.pop(8); 
    strC = ss.pop(8); 
} 

---

Update 1

Danke Jungs. Ich versuche alle Antworten, die du mir gegeben hast, eins nach dem anderen. Ich bin Neuling in C++, also braucht es Zeit, es zu verstehen. Das Folgende ist Anders Ks.

struct S { char four[4]; char eight1[8]; char eight2[8]; }; 
struct S *p = reinterpret_cast<S*>(&_data); 
cout << p->four << endl; // => Output "(" I think I can find way to output 

---

aktualisieren 2

Es string :: substr arbeitet mit. Danke Zakir.

int main() 
{ 
    // I don't know how to change to string value in smart way.. 
    string str; 
    for (std::size_t i = 0; i < _data.size(); ++i) { 
     str += bitset<8>(_data.c_str()[i]).to_string(); 
    } 

    cout << str << endl; // 0000000000000000000000000000000000000000000001111001110001111111001110000010110000001011101101000000000000000000000000000000000000000000000000000000000000000001 

    std::string d = str; // Your binary stream goes here 
    int lenA = (4*8); // First 4 Bytes 
    int lenB = (8*8); // Second 8 Bytes 
    int lenC = (8*8); // Last 8 Bytes 

    std::string strA = d.substr(0, lenA); 
    std::string strB = d.substr(lenA + 1, lenB - 1); 
    std::string strC = d.substr(lenA + lenB + 1, lenC - 1); 

    cout << strA << endl; // 00000000000000000000000000000000 
    cout << strB << endl; // 000000000000111100111000111111100111000001011000000101110110100 
    cout << strC << endl; // 000000000000000000000000000000000000000000000000000000000000001 
} 

---

Update 3

bekam ich einen Fehler, wenn ich Scheff Weg versuchen. Das ist meine Schuld und ich denke ich kann es lösen. Und ich denke, ich sollte über Datas Typ nachdenken.

int main 
{ 
    const char data = _data; 
    const char *iter = data; 
    string strA = pop(iter, 4); 
    string strB = pop(iter, 8); 
    string strC = pop(iter, 8); 
    cout << "strA: '" << strA << "'" << endl; 
    cout << "strB: '" << strB << "'" << endl; 
    cout << "strC: '" << strC << "'" << endl; 
} 

Make Fehlermeldung

error: no viable conversion from 'string' (aka 'basic_string<char, char_traits<char>, allocator<char> >') to 
    'const char' 
const char data = _data; 

Answer 1

ich Ihnen eine sehr einfache Alternative vorschlagen string::substr

#include <iostream> 
#include <string> 
using namespace std; 

int main() 
{ 
    string _data="00010001001000100011001101000100\ 
0101010101100110011101111000100010011001101010101011101111001100\ 
1101110111101110111111111101111010101101101111101110111100000000"; 

    int lenA = (4*8); //First 4 Bytes 
    int lenB = (8*8); //Second 8 Bytes 
    int lenC = (16*8); //Last 16 Bytes 

    string strA = _data.substr(0, lenA - 1); 
    string strB = _data.substr(lenA, lenB - 1); 
    string strC = _data.substr(lenB, lenC - 1); 

    std::cout << "strA: " << strA << endl; 
    std::cout << "strB: " << strB << endl; 
    std::cout << "strC: " << strC << endl; 


    return 0; 
} 

Dies ist sauber und einfach verwenden, aber wird Ihre Arbeit erledigt!
Demo here

Ausgang: -

strA: 0001000100100010001100110100010 
strB: 010101010110011001110111100010001001100110101010101110111100110 
strC: 100110011010101010111011110011001101110111101110111111111101111010101101101111101110111100000000 

Answer 2

Es ist nicht möglich, eine neue Methode zur std::stringstream zu machen. (Zumindest würde ich das nicht empfehlen.)

Stattdessen würde ich vorschlagen, es zu einer Funktion zu machen. Die Verwendung wäre ähnlich.

#include <bitset> 
#include <iostream> 
#include <sstream> 
#include <string> 

using namespace std; 

string pop(istream &in, size_t n) 
{ 
    string ret; 
    while (n--) { 
    unsigned char byte = (unsigned char)in.get(); 
    ret += bitset<8>(byte).to_string(); 
    }  
    return ret; 
} 

int main() 
{ 
    string data(
    "\x11\x22\x33\x44\x55\x66\x77\x88\x99\xaa" 
    "\xbb\xcc\xdd\xee\xff\xde\xad\xbe\xef\x00", 20); 
    istringstream in; in.str(data); 
    string strA = pop(in, 4); 
    string strB = pop(in, 8); 
    string strC = pop(in, 8); 
    cout << "strA: '" << strA << "'" << endl; 
    cout << "strB: '" << strB << "'" << endl; 
    cout << "strC: '" << strC << "'" << endl; 
    return 0; 
} 

Output:

strA: '00010001001000100011001101000100' 
strB: '0101010101100110011101111000100010011001101010101011101111001100' 
strC: '1101110111101110111111111101111010101101101111101110111100000000' 

Anmerkung:

1. Verwenden ein std::istream macht es anwendbar auf jeden von std::istream abgeleiteten Strom.

2. Es gibt keine Fehlerbehandlung in pop(). Daher könnte das Ergebnis von pop() falsch sein, wenn der übergebene Stream danach nicht good() ist.

Btw. Ich stimme den Kommentaren zu, dass ein std::stream "überentwickelt" sein könnte.Also hier die "leichte" Version:

#include <bitset> 
#include <iostream> 
#include <string> 

using namespace std; 

string pop(const char *&iter, size_t n) 
{ 
    string ret; 
    while (n--) { 
    ret += bitset<8>((unsigned char)*iter++).to_string(); 
    } 
    return ret; 
} 

int main() 
{ 
    const char data[] = 
    "\x11\x22\x33\x44\x55\x66\x77\x88\x99\xaa" 
    "\xbb\xcc\xdd\xee\xff\xde\xad\xbe\xef\x00"; 
    const char *iter = data; 
    string strA = pop(iter, 4); 
    string strB = pop(iter, 8); 
    string strC = pop(iter, 8); 
    cout << "strA: '" << strA << "'" << endl; 
    cout << "strB: '" << strB << "'" << endl; 
    cout << "strC: '" << strC << "'" << endl; 
    return 0; 
} 

Der Ausgang ist identisch wie oben.

Hinweis:

1. Die Nutzung von char[] und char* ist viel empfindlicher für out-of-gebundenen Zugang. Daher muss es sorgfältig verwendet werden.

2. Ich bin nicht ganz sicher, ob die (unsigned char) Besetzung notwendig ist. Da ich oft "komische" Effekte bezüglich char, int und Zeichenerweiterungen gesehen habe, schätze ich, dass es nicht schaden kann. (Ich fühle mich besser mit ihm.)