Dezimal in Binär

hallo,

ich bin totaler C anfänger. wir sollen ein programm schreiben was dezimalzahlen zwischen 0 und 1 ind binärzahlen umrechnet und ausgibt. das ganze solange bis das multiplikationsverfahren abbricht oder 15 nachkommastellen ausgegeben wurden.

haber bisher das hier

#include <stdio.h>
int main ()

{

float zahl,kont;
float ergebnis;
int i,binär,x;
i=0;

do
{
printf("zahl eingeben:");
scanf("%f", &zahl);

if (zahl<1 && zahl>=0) {
printf("0,");
ergebnis = zahl*2;
}

while (ergebnis>=1)
{
printf("1");
ergebnis = ergebnis - 1;
ergebnis = ergebnis*2;

}

while (ergebnis<1)
{
printf("0");
ergebnis = ergebnis*2;

}

while(zahl>1 || zahl<=0);

return 0;

allerdings weiss ich nicht mehr weiter. ich bräuchte irgendwie ne anweisung die an den anfang der while (ergebnis>=1) schleife geht und das ganze von vorne beginnt oder so. und dann auch noch 15 mal....
keine ahnung wie ich das machen soll.
bis auf so einfach while,for,if,else schleifen haben wir bisher nichts gelernt. also wäre nett wenn ihr es in dieser art halten könntet.

danke und gruß

Es gibt eine fertige Funktion die dir helfen kann. Wenn du sie verwenden darfst.....? -> strtol -> google mal!

Hi jesus !

jebus schrieb:

bis auf so einfach while,for,if,else schleifen haben wir bisher nichts gelernt.

Oooch...tätschel...das reicht aus, um Betriebssysteme zu programmieren *fg*.

Gucke mal nach C/C++ Tags für zum Code einrücken

kuckma schrieb:

Es gibt eine fertige Funktion die dir helfen kann. Wenn du sie verwenden darfst.....? -> strtol -> google mal!

strtol macht aus Dezimalzahlen zwischen 0 und 1 Binärzahlen ? uiii

Ist bestimmt ne Schulaufgabe, ne ?
Ich hab nicht nur zu meckern, auch was brauchbares,
hier gugge ma mit C/C++ Tags:

#include <math.h>
#define NK 15 // Nachkommastellen

int main(int argc, char *argv[])
{
	float z = 0;
	int   i = 0;

	char binaer_zahl[NK + 1];

	memset( binaer_zahl, '\0', NK + 1 );

	scanf( "%f", &z );

	if ( z <= 0 || z > 1 ) return 0;
	// automatic else implizit ;-)
		for ( i = 0; i < NK; i++ )
		{
			z *= 2;
			if  ( z > 1 )
			{
				binaer_zahl[i] = '1';
				z -= 1;
				continue;
			}
			if ( z == 1 ) 
			{   binaer_zahl[i] = '1';
				break;
			}
			if ( z < 1 )
			{
				binaer_zahl[i] = '0';
			}
		}

	// Rückrechnung zur Kontrolle
	for ( z = 0, i = 0; i < NK; i++ )
	{
		if ( binaer_zahl[i] == '1' )
		{
			z += 1 / pow( 2, i+1 );
		}
	}

	printf("%f -> %s\n\n", z, binaer_zahl );

	return 0;

 }

LG,
p.

#include <limits.h>
#include <stdio.h>

char *binary(char *buf, int x) { /* buf muss mindestens sizeof(int) * CHAR_BIT + 1 Zeichen breit sein */
  int const size = sizeof(int) * CHAR_BIT;

  int i;
  char *p;

  buf[size] = '\0';

  for(i = 0, p = &buf[size - 1]; i < size; ++i, --p) {
    *p = '0' + (x >> i & 1);
  }

  return buf;
}

int main(void) {
  char buf[sizeof(int) * CHAR_BIT + 1];

  puts(binary(buf, 1));

  return 0;
}

strtol macht das ganze dan umgekehrt.

puts(binary(buf, 0.75)) == 000000000000 -> abgesehen davon, das diese Funktion falsche Ergebnisse liefert, sollte man mit Bitshiftoperatoren nicht rechnen, auch wenn das noch so toll und kompakt ausieht, weil das der Mikroprozessor wesentlich effizienter, schneller macht.
MfG,
p.

Eh, hab mich da verkuckt. Ich dachte, es ginge um ints.

Naja - dann stellt sich die Frage nach der Darstellung. Wie schreibt man reelle Zahlen eigentlich in Binär?

proggingmania schrieb:

puts(binary(buf, 0.75)) == 000000000000 -> abgesehen davon, das diese Funktion falsche Ergebnisse liefert, sollte man mit Bitshiftoperatoren nicht rechnen, auch wenn das noch so toll und kompakt ausieht, weil das der Mikroprozessor wesentlich effizienter, schneller macht.
MfG,
p.

Hör bitte auf hier so einen Schwachsinn zu posten. Danke.

Nachtrag: Das mit dem Mikroprozessor (ich nehme an, du meinst da eigentlich den mathematischen Coprozessor) halte ich für ziemlichen Unfug. Wenn die Aufgabenstellung mit ints gewesen wäre, sähe ich hier keinen besseren Weg als Bit-Operationen - immerhin gehts ja um die Bits. Das ist ja auch keine Berechnung im eigentlichen Sinne - wenn ich rechnen will, benutze ich die Zahlen direkt - sondern lediglich das Auseinanderpfriemeln, ums nachher darstellen zu können.

Tim schrieb:

Hör bitte auf hier so einen Schwachsinn zu posten. Danke.

Was denn fürn Schwachsinn ? Das ist das Ergebnis der obigen binary Funktion.

seldon schrieb:

Das mit dem Mikroprozessor (ich nehme an, du meinst da eigentlich den mathematischen Coprozessor) halte ich für ziemlichen Unfug.

Also, warum die Multiplikation schneller als Bitshift ist kann ich dir auch nicht sagen. Das hab ich so gelernt, man könnte es natürlich auch nachprüfen, wozu ich jetzt aber echt keine Lust habe.
MfG,
p.