Come convertire stringa di valori binari torna a char

Question

Esempio

NOTA: che io sono solo preoccupato per le lettere. quindi il set di bit 000001 sarebbe a o A.

Ho un string denominato s con il valore "abc". Prendo ogni char del string e convertirla in valore binario attraverso l'uso di bitset.

es

bitset <6> b1 = s[0]; //a 
bitset <6> b2 = s[1]; //b 
bitset <6> b3 = s[2]; //c 

poi voglio mettere i risultati in un array di strings. Il nome della matrice è arr (e ciascuno string del array rappresenterà il valore binario di ciascun char)

es

arr[0] //will hold the value of char 'a' in binary form which is 000001 
arr[1] //will hold the value of char 'b' in binary form which is 000010 
arr[2] //will hold the value of char 'c' in binary form which is 000011 

e il modo converto ogni char dal string a binario è

arr[0] = b1.to_string(); //arr[0] is now 000001 
arr[1] = b2.to_string(); //arr[1] is now 000010 
arr[2] = b3.to_string(); //arr[2] is now 000011 

Ora qui giace il mio problema. Come posso convertirli di nuovo in char?

esempio

//I want each char to take back the each corresponding letter from the binary values 

char c1; //How do i make the arr[0] value of 000001 to become 'a' again? 
char c2; //Same here 
char c3; //And here 

Answer 1

Supponendo che si desidera iniziare a codice ASCII 64, e che 'a' (o 'A') è semplicemente 000001 in quel caso, allora si può semplicemente fare

c1 = static_cast<char>(std::bitset<6>(arr[0]).to_ulong() + 64); // 

'A' in decimale è 65, in binario è 0b01000001. 'a' in decimale è 97, in binario è 0b01100001. Nel codice, si utilizza un bitset<6> per memorizzare 'a' (o 'A'). Un bitset<6> può rappresentare solo 2^6 simboli, vale a dire 64, in modo da incontrare il taglio. Fondamentalmente verranno tagliati i bit più significativi 2. In questo caso, bitset<6>('A') diventa 0b000001, ovvero 1 in decimale e bitset<6>('a') diventa 0b1000001, ovvero 33 in decimale. Ora puoi convincerti che l'aggiunta di 64 produce il risultato giusto.

EDIT

Si noti che è possibile utilizzare anche std::stoi (C++ 11 solo) per convertire la stringa di bit da base 2 a decimale, come detto in altre risposte:

char c1 = static_cast<char>(std::stoi(arr[0], nullptr, 2) + 64); 

Answer 2

considerare quanto segue:

std::cout << "abc" << std::endl; 

std::cout << 'a' << 'b' << 'c' << std::endl; 

std::cout << std::dec 
      << static_cast<int>('a') << " " 
      << static_cast<int>('b') << " " 
      << static_cast<int>('c') << " "<< std::endl; 

std::cout << std::hex 
      << static_cast<int>('a') << " " 
      << static_cast<int>('b') << " " 
      << static_cast<int>('c') << " "<< std::endl; 

con uscita

abc

abc

Ciò dimostra che ogni char è binario, e 97 Dic è 0x61 esadecimale.

La conversione (da/verso binario tramite bitset) non è necessaria.

(o forse non capisco perché non vuoi fare nulla in un modo un po 'complicato).

Nota che il static_cast < non causa alcuna generazione di codice. Nota che std :: dec e std :: hex non modificano i dati, solo per la radice.

modifica --- Per soli 8 bit, si potrebbe considerare questo ... nessun problema di endian.

std::cout << ((('a' >> 7) & 1) ? '1' : '0') 
      << ((('a' >> 6) & 1) ? '1' : '0') 
      << ((('a' >> 5) & 1) ? '1' : '0') 
      << ((('a' >> 4) & 1) ? '1' : '0') 
      << ((('a' >> 3) & 1) ? '1' : '0') 
      << ((('a' >> 2) & 1) ? '1' : '0') 
      << ((('a' >> 1) & 1) ? '1' : '0') 
      << ((('a' >> 0) & 1) ? '1' : '0') << " " 
      << ((('b' >> 7) & 1) ? '1' : '0') 
      << ((('b' >> 6) & 1) ? '1' : '0') 
      << ((('b' >> 5) & 1) ? '1' : '0') 
      << ((('b' >> 4) & 1) ? '1' : '0') 
      << ((('b' >> 3) & 1) ? '1' : '0') 
      << ((('b' >> 2) & 1) ? '1' : '0') 
      << ((('b' >> 1) & 1) ? '1' : '0') 
      << ((('b' >> 0) & 1) ? '1' : '0') << " " 
      << ((('c' >> 7) & 1) ? '1' : '0') 
      << ((('c' >> 6) & 1) ? '1' : '0') 
      << ((('c' >> 5) & 1) ? '1' : '0') 
      << ((('c' >> 4) & 1) ? '1' : '0') 
      << ((('c' >> 3) & 1) ? '1' : '0') 
      << ((('c' >> 2) & 1) ? '1' : '0') 
      << ((('c' >> 1) & 1) ? '1' : '0') 
      << ((('c' >> 0) & 1) ? '1' : '0') << " " 
      << std::endl; 


std::cout << std::dec << std::endl; 


// with variable 
char zulu = 'A'; 

std::cout << std::dec 
      << "NOTE: in this cout, every use of zulu is a 'read' \n" 
      << " zulu: " << zulu        << " \n" 

      << " dec : " << std::dec << static_cast<int>(zulu) << " \n" 
      << " --- : " << zulu        << " \n" // zulu not changed 

      << " hex : " << std::hex << static_cast<int>(zulu) << " \n" 
      << " --- : " << zulu        << " \n" // zulu not changed 

      << " bin : " 
      << (((zulu >> 7) & 1) ? '1' : '0') 
      << (((zulu >> 6) & 1) ? '1' : '0') 
      << (((zulu >> 5) & 1) ? '1' : '0') 
      << (((zulu >> 4) & 1) ? '1' : '0') 
      << (((zulu >> 3) & 1) ? '1' : '0') 
      << (((zulu >> 2) & 1) ? '1' : '0') 
      << (((zulu >> 1) & 1) ? '1' : '0') 
      << (((zulu >> 0) & 1) ? '1' : '0') << " \n" 
      << " --- : " << zulu        << " \n" // zulu not changed 

      << " bitset: " << std::bitset<8>(zulu)    << " \n" 
      << " zulu: " << zulu        << " \n\nzulu not changed!" // zulu not changed 

      << std::endl; 

Answer 3

Dal momento che lei ha dichiarato non è più necessario il std::bitset dopo la conversione da binario di nuovo al vostro char rappresentazione, si può evitare di utilizzarlo per la conversione.

static_cast<char>(std::stoi(arr[i],0,2) + 64); 

interpreta la rappresentazione binaria originale come numero base 2 (binario) e aggiunge 64. Poiché avete originali char s memorizzati in un formato binario nella matrice arr, è possibile passarli a std::stoi e specificare che i valori sono base 2, nel 3 ° parametro. std::stoi richiede 3 parametri: la stringa che si sta tentando di convertire, un puntatore a un int che memorizzerà l'indice del primo carattere non convertito (non necessario qui, quindi può essere lasciato come 0) e la base dell'argomento stringa. Here's more info on that. Il risultato della chiamata std::stoi è l'equivalente di base 10 (decimale) dei valori binari. La risposta di vsoftco spiega perché l'aggiunta di 64 è l'operazione appropriata da eseguire qui dopo aver ottenuto una rappresentazione decimale. Il risultato di questo è restituito come char.

Se potete permettervi di utilizzare una più grande std::bitset si può anche aggiungere rottami 64.

Ecco una demo live:

Demo