Hallo leute!

bin grade dabei ein simples programm zu schreiben, dass dezimal einliest und dual ausliest.

ich möchte dabei nach folgendem prinzip vorgehen:

for-schleife mit ner laufvariablen i

n=dezimalzahl%2

dezimazahl/2

if abfrage

die werte werden in ein feld geschrieben und dann umgekehrt ausgegeben, da ich sie ja "falschrum" reinschreibe.

das es einfacher geht zb mit bitset oda so weiß ich, darf ich aber nicht benutzen

ich hab ma angefangen aber es kommt ein fehler bei der ausgabe vom feld:

#include <iostream>

#include <conio.h>



using namespace std;


int main()


{

	int i,n,dezi;

	int binarray[33];


	cout << "				Dezimal in Binaer			\n\n";

	cout << " Bitte geben sie die umzurechnende Dezimalzahl ein \n\n\n";


	cin >> dezi;

	cout << "\n";



	for (i=0;i<33;i++)

	{

		n= dezi%2;

		dezi=dezi/2;

		if (n==0)

			binarray[i]=0;

		if (n==1)

			binarray[i]=1;


	}



	cout << binarray;


getch();


return 0;


}

über nette antworten / hilfe würd ich mich freun

danke schonmal

Bearbeitet 12. November 200817 j von eryx
hab paar unsinnige zeilen gelöscht

Es gibt keinen Ausgabeoperator für int-Arrays. Entweder gibst du mit einer Schleife jedes Element einzeln aus, oder benutzt ein char-Array. Dann darfst du aber die Terminierung nicht vergessen.

Und beim nächsten Mal bitte ein paar Details mehr zur Fehlermeldung. "Ein Fehler" hilft bei einem etwas komplexeren Problem schon nicht mehr weiter.

okay dann änder ich dass ma in char um,

was meinst du mit terminierung?

sorry bin im 1. semester, und noch net so viel ahnung

danke aber schonma für die fixe antwort !!!

ps habs in

char binarray[i];

geändert und jetzt kommt bei der ausgabe zwei ":) :)" lol ^^

was meinst du mit terminierung?

Das letzte Zeichen einer Zeichenkette muss stets "\0" sein, damit das Ende erkannt wird.

ps habs in

char binarray[i];

geändert und jetzt kommt bei der ausgabe zwei ":) :)" lol ^^

Ich hoffe mal, dass ich das richtig deute :

Du hast "i" an der Stelle nicht mit irgendeinem Wert initialisiert. Daher steht darin irgendetwas, was sich noch im Speicher befindet und was Du nicht kennst. Aus diesem Grunde kommt auch ein potentiell unsinniges Ergebnis zustande. Dies ist jedenfalls ein Fehler, welchen ich in C binnen kurzer Zeit sehr oft gemacht habe - und es hat lange gebraucht, bis ich dies auch als Fehler erkannt habe.

ja wenn ich 3 z.b eingebe kommen die 2 smileys ^^

mh okay wie merz ich diesen fehler aus? muss ja irgendwie den wert da rauslöschen... nur wie?

hab mit arrays noch fast keine erfahrung

zur terminierung, das hab ich verstanden aber wie setz ich das um?

ja wenn ich 3 z.b eingebe kommen die 2 smileys ^^

Wenn du mit char arbeitest, musst du die Zeichen '0' und '1' ins Array schreiben, nicht die Zahlenwerte 0 und 1.

Die Terminierung ist '\0'.

Du hast "i" an der Stelle nicht mit irgendeinem Wert initialisiert.

Natürlich hat er das, siehe Schleifenkopf.

ja wenn ich 3 z.b eingebe kommen die 2 smileys ^^

mh okay wie merz ich diesen fehler aus? muss ja irgendwie den wert da rauslöschen... nur wie?

Bei Char-Arrays darfst du nicht Werte wie 1 oder 0 speichern.

Entweder '0'/'1' oder 0x30/0x31

hab mit arrays noch fast keine erfahrung

zur terminierung, das hab ich verstanden aber wie setz ich das um?

Sind auch nur Pointer...

Letztes Element auf '\0' bzw. 0x00 setzen.

sauber nu machts was ich will (vorerst ^^)

so dann mach ich mich ma an die umgekehrte ausgabe, da muss ich mit shifts arbeiten oda?

schonma vielen dank, hast mich schonma weitergebracht

Warum nimmst du überhaupt einen Array?

Du kannst das ganze auch während der Schleife ausgeben lassen.

Shiftoperator und %-Bitverkettungsoperator wirken da wahre Wunder.

Natürlich hat er das, siehe Schleifenkopf.

Wenn

int binarray[33];

in

char binarray[i];

geändert wurde, so ist dies vor dem Schleifenkopf. So habe ich das jetzt jedenfalls interpretiert.

@ tdm

wie sähe denn ein ansatz für bitoperatoren aus?

ich weiß ja dass wenn ich

cin >> dezi;

eingebe die zahl dual gespeichert wird...

nur wie nutz ich das im zusammenhang mit bitoperatoren?

sooo

also ich hab jetzt die reihenfolge umgekehrt in dem ich einfach i auf 33 gesetz hab und mit i-- runterzähle

nun hab ich aber wieder ein problem mit der "terminierung"

denn wenn ich als dezi = 6 eingebe schreibt er "000..110|||| "

also nach der letzten 0 nur müll.

wie muss das richtig laufen mit der terminierung, wenn ich das feld rumgedreht ausgebe bzw einlese?

#include <iostream>

#include <conio.h>



using namespace std;


int main()


{

	int i,n,dezi;

	char binarray[33];

	binarray[33] = '\0';


	cout << "				Dezimal in Binaer			\n\n";

	cout << " Bitte geben sie die umzurechnende Dezimalzahl ein \n\n\n";


	cin >> dezi;

	cout << "\n";



	for (i=33;i>=0;i--)

	{

		n= dezi%2;

		dezi=dezi/2;

		if (n==0)

			binarray[i]='0';

		if (n==1)

			binarray[i]='1';




	}



	cout << binarray;


getch();


return 0;


}

Du setzt "\0" als letztes Element und überschreibst es beim ersten Schleifendurchlauf gleich wieder

Noch schlimmer: Du greifst auf ein char zu, das außerhalb des Arrays liegt.

Wenn du ein Array mit 33 Elementen anlegst, dann ist der höchste erlaubte Index, mit dem du darauf zugreifen darfst, 32.

ja ich hab hald ma alles durchprobiert...

wenn ich binarray[32] = '\0' hab steht das selbe da

und ich habs jetzt direkt vor cout gesetzt

binarray[32] = '0';


	cout << binarray;

:(

aaaaaaaaaaaaah!!!!!!!!!!!!!! ich haaaaaabs !!!!

:bimei

hab die forschleife geändert (den tipp mit dem höchsten eben erst geraftt ^^ habs vorher auf die terminierung bezogen )

for (i=32;i>=0;i--)

jetzt gibts keine komische zeichen mehr und alles läuft

danke an alle für eure mühe !

hätte nur noch ne frage ob ich mit der array methode die unbenutzen nullen wegbekomme oda ob ich das so hinnehmen muss - da ich keine bitoperatoren und shifts benutze.

lg eryx

@ tdm

wie sähe denn ein ansatz für bitoperatoren aus?

In etwa so:

	int value = 0;

	cout << "Zahl:\t"; cin >> value; cout << endl;


	for (int i = (sizeof(value)<<3); i > 0; i = i>>1)

	{

		cout << ((value & i)!=0);

	}

for (int i = (sizeof(value)<<3); i > 0; i = i>>1)

Ich glaube, du bist da ein wenig durcheinandergekommen, ob in i nun die Zweierpotenzen oder nur die Exponenten stehen sollen. Du fängst bei sizeof(int) * 8 an (mutmaßlich 32) und teilst dann wiederholt durch 2. Damit bekommst du aber nur die letzten 6 Bits.

hmm, stimmt.

Tausche 3 gegen 8. :floet:

Gedacht hatte ich mir eigentlich (sizeof(value)<<(1<<3)). :hells:

Gedacht hatte ich mir eigentlich (sizeof(value)<<(1<<3)). :hells:

Das ist auch Quatsch.

Du meinst vermutlich 1 << (sizeof(int) * 8 - 1)

mh mir is das zu hoch ^^ noch nie was von

(sizeof(value)<<(1<<3))

sizeof usw gehört

was macht der befehl?

<< 3 heißt 3 shifts nach links?

mh mir is das zu hoch ^^ noch nie was von sizeof usw gehört

was macht der befehl?

sizeof ist ein Operator, kein Befehl. Befehle gibt's eigentlich in C und C++ gar nicht.

sizeof gibt die Größe (Speicherbedarf) eines Typs (oder des Typs eines Ausdrucks) zurück, und zwar zur Compilezeit (Ausnahme: VLAs in C99). sizeof( char ) ist per Definition 1.

Wenn man sizeof mit Typen benutzt, muss man Klammern benutzen. Bei Ausdrücken kann man die Klammern weglassen.

<< 3 heißt 3 shifts nach links?

Richtig.

Du meinst vermutlich 1 << (sizeof(int) * 8 - 1)

Ja. :hells:

Wobei, ist auch nicht ganz richtig, weil dann ist bei mir ein Bufferüberlauf (-2147483648) daher eher: (1<<(sizeof(int) * 8-1))-1

was macht den diese for-schleife genau?

for (int i = (sizeof(value)<<3); i > 0; i = i>>1)

soweit ich das verstehe is die shift variabale oder?

also die sagt wieoft geshiftet wird.

Wobei, ist auch nicht ganz richtig, weil dann ist bei mir ein Bufferüberlauf (-2147483648)

Nein, das ist für einen 32-Bit-int der richtige Wert: 0x80000000

daher eher: (1<<(sizeof(int) * 8-1))-1

Damit hast du einen Underflow.

soweit ich das verstehe is die shift variabale oder?

also die sagt wieoft geshiftet wird.

Nein, das soll eine Bitmaske sein. Ein Wert, in dem jeweils nur ein einziges Bit gesetzt ist, angefangen mit dem höchsten. Bei jedem Schleifendurchlauf wird der Wert um 1 nach rechts geschoben, so dass das nächstkleinere Bit gesetzt ist, solange bis der Wert 0 erreicht.