Octet de string/int en C++

Question

Je suis un utilisateur débutant en C++ et je veux savoir comment faire: Comment puis-je 'créer' un octet à partir d'une chaîne/int. Ainsi, par exemple, j'ai:

string some_byte = "202"; 

Quand je sauverais cet octet dans un fichier, je veux que le fichier est 1 octet au lieu de 3 octets. Comment est-ce possible? Merci à l'avance, Tim

Answer 1

Je voudrais utiliser la classe String Stream <sstream> de C++ pour convertir la chaîne en un caractère non signé.

Et écrire le caractère non signé dans un fichier binaire.

donc quelque chose comme [pas de code réel]

std::string some_byte = "202"; 
std::istringstream str(some_byte); 
int val; 
if(!(str >> val)) 
{ 
    // bad conversion 
} 

if(val > 255) 
{ 
    // too big 
} 

unsigned char ch = static_cast<unsigned char>(val); 

printByteToFile(ch); //print the byte to file. 

Answer 2

Utiliser boost :: lexical_cast

#include "boost/lexical_cast.hpp" 
#include <iostream> 

int main(int, char**) 
{ 
    int a = boost::lexical_cast<int>("42"); 
    if(a < 256 && a > 0) 
     unsigned char c = static_cast<unsigned char>(a); 

} 

Vous trouverez la documentation à http://www.boost.org/doc/libs/1_43_0/libs/conversion/lexical_cast.htm

Toutefois, si l'objectif est d'économiser de l'espace dans un fichier, je ne Je pense que c'est la bonne façon d'y aller. Comment se comportera votre programme si vous voulez convertir "257" en octet? Juste aller pour le plus simple. Vous travaillerez plus tard toute préoccupation d'utilisation de l'espace si elle est pertinente (règle de base: utilisez toujours « int » pour les entiers et non d'autres types moins qu'il y ait une raison très spécifique autre que début optimisation)

EDIT Comme les commentaires le disent, cela ne fonctionne que pour les entiers, et le passage aux octets ne le fera pas (il lèvera une exception). Alors, que se passera-t-il si vous essayez d'analyser "267"? À mon humble avis, il devrait passer par un int, puis faire quelques tests de limites, puis seulement lancer dans un char. Traverser atoi par exemple entraînera des bogues extreamly sujettes.

Answer 3

En C++, coulée à/à partir de chaînes est le mieux fait en utilisant les flux de chaîne:

#include <sstream> 
// ... 
std::istringstream iss(some_string); 
unsigned int ui; 
iss >> ui; 
if(!iss) throw some_exception('"' + some_string + "\" isn't an integer!"); 
unsigned char byte = i; 

Pour écrire dans un fichier, vous utilisez le fichier ruisseaux. Cependant, les flux écrivent/lisent généralement leurs données sous forme de chaînes. vous devrez ouvrir le fichier en mode binaire et binaire écrire aussi:

#include <fstream> 
// ... 
std::ofstream ofs("test.bin", std::ios::binary); 
ofs.write(reinterpret_cast<const char*>(&byte), sizeof(byte)/sizeof(char)); 

Answer 4

La réponse est simple ...

int value = atoi(some_byte) ; 

Il y a quelques questions bien.

1) Quelle est la taille d'un int et est-ce important? (Pour presque tous les systèmes, il va être plus d'un octet)

int size = sizeof(int) ; 

2) Est-ce le Endianness important? (si vous regardez dans les fonctions de htons()/ntohs())