Discussion :

[rikau2]

Bonjour a tous,

je recherche dans le cadre de mon projet a implementer deux methodes afin de convertir le contenu d'une string.

Ma striing peut etre sous deux format:

contenir pour chaque char de ma string soit des '0', soit des '1', et je cherche a diminuer par 8 la taille en faisant un stockage plutot du genre:

string initiale

ascii
0 1 0
bin
00110000 00110001 00110000

et je veux stocker directement en bin
010 (pour connaitre la taille, ce n'est pas un probleme)

Comment faire?

J'ai commence quelquechose du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
char *_tmp_char;
int numOfBits =0;
std::string _initstr; // string that use more memory
std::string final; // reduced memory container
 
std::cin >> _initstr; // get a string like 0101010 : 7bits but use 7bytes 
numOfBits= _initstr.length(); 
final.erase();
 
_tmp_char = &final.at(0); 
for (var =0; var < _initstr.length(); var++)
{
  if (_initstr.at(var) != '0' && _initstr.at(var) != '1' )
  {
	numOfBits--;
	std::cout << "error char :"<<_initstr.at(var)<< " at position :"<< var << " is not binary value"<<  std::endl;
  }
  // assign value to string char
  else
  {
	std::cout << _initstr.at(var) << std::endl;
 
	*_tmp_char <<1;  <= ici je sais plus comment faire...
 
 
  }
}

est ce un bon depart?, cela ne me parait pas tres elegant, mais je suis a court d'idee.

cordialement

rikau2

[fdubks]

Salut,

J'avais fait il y a quelques temps une fonction qui transformé une chaine representant un octet en binaire dans le format hexa.
Cela peut t'aider peut être.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
	std::string mystr;
 
	std::cout << "Enter a number: ";
	std::cin >> mystr;
 
	//ss << mystr;
 
	int monEntier=0;
	int puissance = 1;
	for (int i=0; i<8; i++)
	{
		int val = mystr[i]=='1'?1:0;
		val *= puissance;
		monEntier +=  val; 
		puissance *= 2;
	}
	std::cout << " " << std::hex << monEntier << std::endl;

[Grulim]

Peux-tu utiliser la balise CODE ?

Peux-tu m'expliquer pourquoi tu veux faire ça ?

[rikau2]

desole pour l'oublie de la balise code, c'etait mon premier post.

Je cherche a faire cela car pour communiquer avec des cartes reseaux, je doit convertir ma trame en une sequence reelle de bits et non une string contenant les pseudo bits modelises par des caracteres 0 ou 1.

Je suis dessus depuis mon poste, pensez vous que quelquechose comme ca ca passe??

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
bool LongStringToSmallString (string &toReturn,string _initstr)
{
	int var=0,stringChar=0;
	char temp;
 
	string final;
 
	final.erase();
	final.reserve(  ((_initstr.length()/8)==0) ? 1 : (_initstr.length()/8) ); //reserve the appropriate memory size
 
	for (var =0; var < _initstr.length(); var++)
	{
		if (var%8 == 0) temp=0;
		if (_initstr.at(var) != '0' && _initstr.at(var) != '1' )
		{
			std::cout << "error char :"<<_initstr.at(var)<< " at position :"<< var << " is not binary value"<<  std::endl;
			return false;
		}
		// assign value to string char
		else
		{
			if (_initstr.at(var) == '1') temp |= 1<<(7-var%8);
		}
		if (var%8 == 7)
		{
			final[stringChar++] = temp;
		}		
	}
	toReturn = final;
	return true;
 
}

[Grulim]

En gros:
tu recois une chaine "010101..." -> tu la transforme en une suite d'octets suivant la taille de la chaine.
la longueur de la chaine doit être un multiple de 8, sinon tu dois faire du remplissage (a gauche, à droite, avec des 0 ou des 1) ?

la variable de retour ne devrait pas être un string, mais un vector<unsigned char>, c'est plus logique, non ?

[rikau2]

Merci de votre aide, je suis arrive au code suivant permettant de transformer un stockage de 0 et 1 contenus dans une string chaque 0 et 1 etant des char '0' et '1', au stockage directement dans une string contenant des char qui contiennent chacun 8 valeurs (je sais ce n'est pas du luxe mais ca pourrait aider quelqu'un d'autre).

La taille memoire requise est au plus reduite exactement de 8 fois si la longeur de la string est un multiple de 8 sinon est 8fois inferieur + 1 char.

Je mets donc le code de ma fonction pour qui ca interesse (pardon c'est un peu notre fonction)


Merci encore.

rikau2

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
bool LongStringToSmallString (string &output,string input)
{
	int var=0,stringChar=0;
	char temp;
	string _initstr = entree;
	final.erase(0,final.size());
	final.reserve(  ((_initstr.length()/8)==0) ? 1 : (_initstr.length()/8) ); //reserve the appropriate memory size
 
	for (var =0; var < _initstr.length(); var++)
	{
		if (var%8 == 0) temp=0;
		if (_initstr.at(var) != '0' && _initstr.at(var) != '1' )
		{
			std::cout << "error char :"<<_initstr.at(var)<< " at position :"<< var << " is not binary value"<<  std::endl;
			return false;
		}
		// assign value to string char
		else
		{
			if (_initstr.at(var) == '1') temp |= 1<<(7-var%8);
		}
		if (var%8 == 7)
		{
			final += temp;
		}		
	}
	return true;
 
}

[Grulim]

Tu as testé si on passait "00000000" (8 '0') à ta fonction ?
Et comment réagit la string de sortie avec ce zéro binaire ?

[rikau2]

avec 8 '0' ca marche, je ne change pas l'adresse de mon char mais j'assigne chaque bit de chaque char a une valeur particuliere, tant que je ne lis pas directement cette valeur, il n'y a pas de pb.

Maintenant je me penches sur la conversion inverse, et surprise, ca marche presque, il faut juste inverser la string de retour qui revient inversee..

je donne le code egalement, trouve sur internet, je ne l'ai pas encore trop travaille.

A bientot

rikau2

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
 
#define BITS_PER_BYTE 8
 
unsigned char CharMask[] = { 0x01u, 0x02u, 0x04u, 0x08u,
							 0x10u, 0x20u, 0x40u, 0x80u };
 
unsigned long LongMask[] = { 0x00000001ul, 0x00000002ul, 0x00000004ul, 0x00000008ul,
							 0x00000010ul, 0x00000020ul, 0x00000040ul, 0x00000080ul,
							 0x00000100ul, 0x00000200ul, 0x00000400ul, 0x00000800ul,
							 0x00001000ul, 0x00002000ul, 0x00004000ul, 0x00008000ul,
							 0x00010000ul, 0x00020000ul, 0x00040000ul, 0x00080000ul,
							 0x00100000ul, 0x00200000ul, 0x00400000ul, 0x00800000ul,
							 0x01000000ul, 0x02000000ul, 0x04000000ul, 0x08000000ul,
							 0x10000000ul, 0x20000000ul, 0x40000000ul, 0x80000000ul };
 
 
 
unsigned long GetBits(unsigned char *bitString, unsigned long lOffset, unsigned long lLength)
{
 
	// Note that the lOffset begins at zero.
 
	unsigned long lByteOffset;
	unsigned long lBitOffset;
	unsigned long lValue = 0ul;
	long i;
 
	// Determine the byte at which to start getting bits.
 
	lByteOffset = lOffset / BITS_PER_BYTE;
 
	// Determine the bit position of the byte at which to start getting bits.
 
	lBitOffset = lOffset - lByteOffset * BITS_PER_BYTE;
 
	// Process bit-by-bit.
 
	for (i = lLength-1; i >= 0; i--)
	{
		// Get the bit from the source bit string, and then set it in
		// the destination return value.
 
		if (bitString[lByteOffset] & CharMask[lBitOffset])
			lValue |= LongMask[i];
 
		// Increment the current bit position within the bit string.
 
		lBitOffset++;
		if (lBitOffset > 7)
		{
			lBitOffset = 0;
			lByteOffset++;
		}
	}
 
	// Return the extracted value.
 
	return (lValue);
 
}

[superspag]

oulala... c'est compliqué tout ça

C'est vrai qu'il manque un manipulateur pour la base 2 dans la bibliothèque standart des manipulateurs de flux, mais il existe tout de même la classe bitset... Simplifions nous la vie puisque ça existe déjà

Ça donnerait un truc comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#include <string>
#include <bitset>
#include <sstream>
 
using namespace std;
 
string binaryToAsciiString(const string& inStr)
{
  istringstream is(inStr);
  ostringstream os("");
  bitset<8> b;
  while( is >> b )
    os << static_cast<char>(b.to_ulong());
  return os.str();
}
 
 
int main()
{
  // exemple :
  string res = binaryToAsciiString("000000010000001000000011");
}

NB : à une erreur de frappe prés... je n'ai pas de compilateur sous la main...

[rikau2]

En effet je retire mon example precedent, bitset est beaucoup plus simple et propre a utiliser.