représentation des nombres en binaire

Version imprimable

Bonjour à tous mon programme ci-dessus permet d'afficher les nombres pairs compris entre -150 et 150, je souhaite aussi faire afficher ces nombres en binaire,
je sais pas comment faire.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #include<iostream.h> using namespace std; int main() { int i; for (i=-150; i<150; i=i+2) printf("La valeur de i est : %d\n",i); printf("La valeur finale de i est : %d\n",i); for(;;); }

Hello,

Evite printf en c++ et utilise std::cout :)
Sinon pour ton problème un std::bitset fera l'affaire.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
#include <bitset>
 
int main(int argc, char** argv) {
 
	std::bitset<sizeof(int) * 8> bits;
 
	for(int i=0; i<10; ++i) {
		bits = i;
 
		std::cout << i << ": " << bits << std::endl;
	}
	return 0;
}

13/01/2013, 21h01
EtherOS

juste une proposition

la fonction itoa peut te convertir ces nombres en binaire :

soit :
i l'entier en base 10 qu'il faut convertir en binaire

str la chaine qui va contenir la convertion de i en base 2 .

2 la base de sortie du string

str est de type char*

Code:

itoa(i,str,2);

pour convetir char * en std::string faire:

Code:

std::string s(str);

puis afficher le str:

Code:

std::cout << s<<std::endl;

Pour gérer les nombres négatifs faire un complément à 1 des bits de sortie du string.
a + opp(a) = 1

pour pos allant de 1 à s.size();

par exemple:

Code:

std::cout << 1-atoi(s.substr(pos,1)) << std::endl;
14/01/2013, 14h09
Niark13

itoa n'est pas une fonction standard et n'est présente que sur certains systèmes. Il vaut mieux éviter de l'utiliser.

Faire une fonction de conversion decimal-binaire à base de divisions successives par 2 n'est pas très compliqué. Voici des explications sur comment faire.

Version crade, octet par octet à base de masque sur les bits (fonctionne pour int, float, double, unsigned int, etc...) :

Code:

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
 
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <limits>
 
template < typename T >
std::string to_binary( const T& value ){
        // Masques pour 8 bits.
	static unsigned char flags[] = {
		0x01, //00000001
		0x02, //00000010
		0x04, //00000100
		0x08, //...
		0x10,
		0x20,
		0x40,
		0x80
	} ;
 
	const unsigned char* buffer = reinterpret_cast< const unsigned char* >( &value ) ; 
	// pour chaque octet, on applique les masques
	std::ostringstream oss ;
	for ( int i = 0; i < sizeof(value); i++ ){
		for ( int j = 0; j < 8; j++ ){
			oss << ( ( buffer[i] & flags[j] ) ? 1 : 0 ) ;
		}
	}
 
	std::string result = oss.str() ;
	std::reverse( result.begin(), result.end() );
	return result ; 
}
 
int main( int argc, char* argv[] ){
	std::cout << to_binary( 12.0f ) << std::endl ;
        std::cout << to_binary( 12.0 ) << std::endl ;
        std::cout << to_binary( -4 ) << std::endl ;
        std::cout << to_binary( 4 ) << std::endl ;
	return 0 ; 
}

16/01/2013, 01h52
Bousk
Il existe de nombreux exemples sur le net à l'aide des opérateur & et >> (respectivement et binaire et décallage de bits).
A la louche ça donne
Code:

1 2 3 4 5 for (int i = 0; i < sizeof(value); ++i) { if (value & (1<<i)) // i-ème bit à 1 else // i-ème bit à 0 }
Après on peut imaginer des variantes, par exemple je viens d'imaginer qqch comme ça:
Code:

1 2 3 4 5 for (; value; value>>=1) { if (value & 1) // premier bit à 1 else // à 0 }
En 2mn de debuger tu devrais la mettre au point.