[C/C++] Dezimalzahlen in Dualzahlen umwandeln

gaucho

Herzlich willkommen!
Dezimalzahlen in Dualzahlen umwandeln

hallo,
mir wurde eine aufgabe in der schule zugeteilt und ich habe im moment überhaupt keine ahung wie ich diese bewältigen soll.
es handelt sich um ein programm das mit hilfe von arrays dezimalzahlen in dualzahlen wandelt.
wäre nett wenn ihr mir vll schon ein fertiges programm geben könntet.

mfg
 
gaucho schrieb:
wäre nett wenn ihr mir vll schon ein fertiges programm geben könntet.

Die Frage ist, ob Du das nutzen würdest, um daraus zu lernen oder es zu misbrauchen damit Du Dir Arbeit sparst.

Ich unterstelle Dir aber jetzt nichts Böses.

Schau mal nach, ob dieser Thread Dir hilft. Als ich damals selbst die Aufgabe hatte, musste ich den genannten Code noch an den Compiler anpassen, aber von der Logik her ist es das Selbe.
https://www.supernature-forum.de/pr.../31180-dezimal-dual.html?highlight=dualzahlen
 
Hehe ... Wenn du fertig bist schreib mal deinen Code hier rein ... Bin gespannt, was dabei rausgekommen ist :)

Gruß von einem Fachinformatiker - Anwendungsentwicklung
 
@ diesen beitrag hab ich schon gelesen, bin aber auch nicht schlauer daraus geworden, da dadrin keine arrays vorkommen..aber danke nochma...

@lektro auch danke für dieses muster, kann aber keinen nutzen drauß ziehen da es zu kompliziert ist.. und wenn ich des dem lehrer so vorlege sagt er das des nicht von mir sein kann :D

ej leute ich glaub ich gebs auf....

mfg gaucho
 
Nix aufgeben ;)

Ist Dir denn das Umwandeln der Dezimalzahlen in Binärzahlen überhaupt ein Begriff?

Falls ja, ist der Code recht simpel zu verstehen.

Ich gebe ihn Dir mal aus LERNZWECKEN, er ist auch überall mit Infos versehen. Wenn Du Fragen hast, sag Bescheid aber ich bitte darum, dass Du den nicht zum Bescheißen verwendest :)

Code:
#include<conio.h>
#include<iostream.h>

int zahl,zahl2,rest,dual[16];

void main()
{

// Eingabe der Dezimalzahl
cout<<"Zahl eingeben (max. 65535): ";
cin>>zahl;

// Schleifer läuft 16 mal durch, denn 2^16=65536
for (int z=15;z>=0;z--)
{

// Eingegebene Zahl halbieren und Rest ermitteln
zahl2=zahl/2;
rest=zahl-(zahl2*2);

// Rest in das Array übertragen. Bits werden von rechts nach links übernommen
dual[z]=rest;

// Hälfter der Zahl (ohne Rest) als neue anzufragende Zahl definieren,
// mit der weitergerechnet wird
zahl=zahl2;
}

//Zeilensprung und Ausgabe der Bits (von links nach rechts)
cout<<endl;
for (int z=0;z<=15;z++)
{
cout<<dual[z];
}

getch();
}
 
hi, du bist einfach der geilste (@Hidden Evil :D ). jetz verstehe ich die arrays schon wesentlich mehr. hast mir sehr geholfen.
danke

ciao gaucho
 
@gaucho: Na da freut sich ja jemand :D Gerne doch :)

Brummelchen schrieb:
hmm, Frage - warum mit Array?

Habe ich verwendet, weil es gewünscht war, geht natürlich auch bei der Ausgabe auch ohne ;)

Die sind sowieso nicht in Bool umgewandelt, da hatte ich probleme und habe sie als Integer gelassen.

Ist sowieso auch nur das absolut Geringste. Ausbauen kann man da noch ne Menge :)
 
Was heisst denn das nun "mit array" - bei der Eingabe, Verarbeitung oder Ausgabe?

Das einzige Array ist hier die Ausgabe ;)

PS da ich des C nicht mächtig bin ;) NSIS
Code:
Function calc
  StrCpy $R1 $INPUT
  StrCpy $R5 "1"
  StrCpy $R6 ""

  calc01:
  IntOp $R2 $R1 / 2
  IntOp $R3 $R2 * 2
  IntOp $R4 $R1 - $R3
    StrCpy $R6 "$R4$R6"
    IntOp $R5 $R5 + 1
    IntCmp $R5 5 0 calc02
      StrCpy $R5 "1"
      StrCpy $R6 " $R6"
    calc02:
  StrCpy $R1 $R2
  StrCmp $R1 "1" 0 calc01
  StrCmp $R1 "0" calc03
    StrCpy $R6 "$R1$R6"
  calc03:
  StrCpy $OUTPUT $R6
FunctionEnd
 
Zuletzt bearbeitet:
Kommt doch auch nicht drauf an. :) Die Aufgabe war eine Problemlösung zu finden in der das Thema Array verwendet wird.
Schön wäre es noch gewesen statt int char zu verwenden, so hätte man einen waschechten String, den man in einem Rutsch ausgeben könnte. :)
 
Pennywise schrieb:
Schön wäre es noch gewesen statt int char zu verwenden, so hätte man einen waschechten String, den man in einem Rutsch ausgeben könnte. :)

Geht auch :)
(Nur musste ich die Schleifendurchläufe um 1 reduzieren, sonst wäre ein undefiniertes char mit ans Ende des Strings geraten. Warum weiß ich auch nicht :confused)

Code:
#include<conio.h>
#include<iostream.h>

int zahl,zahl2,rest;
char dual[16];

void main()
{

// Eingabe der Dezimalzahl
cout<<"Zahl eingeben (kleiner als 65535): ";
cin>>zahl;

// Schleifer läuft 15 mal durch
for (int z=14;z>=0;z--)
{

// Eingegebene Zahl halbieren und Rest ermitteln
zahl2=zahl/2;
rest=zahl-(zahl2*2);

// Rest in das Array übertragen. Bits werden von rechts nach links übernommen
if (rest==1)
dual[z]='1';
else
dual[z]='0';

// Hälfte der Zahl (ohne Rest) als neue abzufragende Zahl definieren,
// mit der weitergerechnet wird
zahl=zahl2;
}

//Zeilensprung und Ausgabe der Bits (von links nach rechts)
cout<<endl<<dual;

getch();
}
 
Ich gebe auch mal ein zum besten Ohne Kopf für die Form geschrieben für
MS Visual Studio, hab ich mal ne 1 drauf bekommen, vielleicht ein wenig umfangreich, aber dafür alle 3 Zahlenformen ( Hex Dec Dual ) mit nachkomma

Code:
// knvertierungs-alghorithmen
void CConvertitDlg::deci()
{
	char *BS;BS=new char[2];
	
	m_deci=m_wert;
	UpdateData(FALSE);
	int *vk;//vorkomma
	int *nk;//nachkomma(fallsvorhanden)
	int vkanz=0;int nkanz=0;
	int vork=0;int nachk=0;
	CString zahl=m_wert;
	int lang=zahl.GetLength();
	int komma=zahl.Find(',');
	if (komma==-1){komma=zahl.Find('.');}
	if(komma==-1)
	{
		nk=new int[1];nkanz=0;
		vk=new int[lang];vkanz=lang;
		for(int x=0;x<lang;x++)
		{
			//abc=zahl.GetAt(x);
			BS[0]=zahl.GetAt(x) ;BS[1]=NULL;
			vk[x]=atoi(BS);
		}
	}
	else
	{
		if(komma==0)
		{
			int c=0;
			vk=new int[1];vkanz=1;
			vk[0]=0;
			nk=new int[lang-1];nkanz=lang-1;
			for(int x=1;x<lang;x++)
			{
				BS[0]=zahl.GetAt(x) ;BS[1]=NULL;
				nk[c]=atoi(BS);c++;
			}

		}
		else
		{	int c=0;
			nk=new int[lang-(komma+1)];nkanz=lang-(komma+1);
			vk=new int[komma];vkanz=komma;
			for(int x=0;x<komma;x++)
			{
				BS[0]=zahl.GetAt(x) ;BS[1]=NULL;
				vk[x]=atoi(BS);
			}
			int p=komma;p++;
			for(int f=p;f<lang;f++)
			{
				BS[0]=zahl.GetAt(f) ;
				BS[1]=NULL;
				nk[c]=atoi(BS);
				c++;
				
			}

		}
	}
	char *ayc;
	int y=nkanz;
	ayc=new char[y];
	char bse[10];
	for(y=0;y<nkanz;y++)
	{itoa( nk[y], bse, 10 );ayc[y]=bse[0];ayc[y+1]=NULL;}
	nachk=atoi(ayc);
	y=vkanz;ayc=new char[y];
	for(y=0;y<vkanz;y++)
	{itoa( vk[y], bse, 10 );ayc[y]=bse[0];ayc[y+1]=NULL;}
	vork=atoi(ayc);
	//in nachk steht jetzt die nachkomma zahl
	//in vork steht jetzt die vorkomma zahl
	//in vkanz steht die Anzahl der vorkommastellen und in nkanz der Nachkommastellen
	//in vk[] bzw nk[] die einzelnen ziffern der vorkomma bzw nackommazahlen

	// UMRECHNUNG --> Hexadezimal
	// Modulu a=19%7  a=5 (19/7=2 rest 5)
	/*702,3D

	702 : 16 = 43 R E			0,3 x 16 = 0,8 R 4
	 43 : 16 =  2 R B			0,8 x 16 = 0,8 R C
	  2 : 16 =  0 R 2 		
			702,3  Dec		=>	2BE,4C  Hex
*/
	int fs=vork;
	int rest=0;
	int a=1;int d=0;
	for(fs;fs>0;a++)
	{
		rest=fs%16;
		fs=fs-rest;
		fs=fs/16;
	}
	char *wert;CString *vbin;CString nurso;
	wert=new char[a];
	a--;wert[a]=NULL;vbin=new CString[a];a--;
	fs=vork;
	for(a;a>-1;a--)
	{
		rest=fs%16;
		fs=fs-rest;
		fs=fs/16;
		switch(rest)
		{
		case 0:wert[a]='0';vbin[a]="0000 ";break;
		case 1:wert[a]='1';vbin[a]="0001 ";break;
		case 2:wert[a]='2';vbin[a]="0010 ";break;
		case 3:wert[a]='3';vbin[a]="0011 ";break;
		case 4:wert[a]='4';vbin[a]="0100 ";break;
		case 5:wert[a]='5';vbin[a]="0101 ";break;
		case 6:wert[a]='6';vbin[a]="0110 ";break;
		case 7:wert[a]='7';vbin[a]="0111 ";break;
		case 8:wert[a]='8';vbin[a]="1000 ";break;
		case 9:wert[a]='9';vbin[a]="1001 ";break;
		case 10:wert[a]='A';vbin[a]="1010 ";break;
		case 11:wert[a]='B';vbin[a]="1011 ";break;
		case 12:wert[a]='C';vbin[a]="1100 ";break;
		case 13:wert[a]='D';vbin[a]="1101 ";break;
		case 14:wert[a]='E';vbin[a]="1110 ";break;
		case 15:wert[a]='F';vbin[a]="1111 ";break;
		default:break;
		}
		nurso=vbin[a]+nurso;
	}
	m_bini=nurso;
	m_hexi=wert;//vorkamma in HEX gewandelt
	UpdateData(FALSE);
	if(nkanz>0)
	{
	vbin=new CString[7];nurso="";
	char *nwert;nwert=new char[8];nwert[7]=NULL;
	double nkl=nachk;
	for(int zaehler=0;zaehler<nkanz;zaehler++)
	{nkl=nkl/10;}//aus der nachkomma zahl eine 0,zahl 
	a=0;int erg=0;
	for(a;a<7;a++)
	{
		nkl=nkl*16;
		erg=nkl;
		nkl=nkl-erg;
		switch(erg)
		{
		case 0:nwert[a]='0';vbin[a]="0000 ";break;
		case 1:nwert[a]='1';vbin[a]="0001 ";break;
		case 2:nwert[a]='2';vbin[a]="0010 ";break;
		case 3:nwert[a]='3';vbin[a]="0011 ";break;
		case 4:nwert[a]='4';vbin[a]="0100 ";break;
		case 5:nwert[a]='5';vbin[a]="0101 ";break;
		case 6:nwert[a]='6';vbin[a]="0110 ";break;
		case 7:nwert[a]='7';vbin[a]="0111 ";break;
		case 8:nwert[a]='8';vbin[a]="1000 ";break;
		case 9:nwert[a]='9';vbin[a]="1001 ";break;
		case 10:nwert[a]='A';vbin[a]="1010 ";break;
		case 11:nwert[a]='B';vbin[a]="1011 ";break;
		case 12:nwert[a]='C';vbin[a]="1100 ";break;
		case 13:nwert[a]='D';vbin[a]="1101 ";break;
		case 14:nwert[a]='E';vbin[a]="1110 ";break;
		case 15:nwert[a]='F';vbin[a]="1111 ";break;
		default:break;
		}
		nurso+=vbin[a];
	}
	m_bini+=", ";
	m_bini+=nurso;
	m_hexi+=',';
	m_hexi+=nwert;
	UpdateData(FALSE);
	}



	delete[] vk;
	delete[] nk;
	delete[] BS;
	//delete[] ayc; // wenn delete dann fehler??
}


void CConvertitDlg::hexi()
{
	m_hexi=m_wert;
	UpdateData(FALSE);
	int vkanz=0;int nkanz=0;
	CString zahl=m_wert;
	int *vk;int *nk;CString *vbin;CString *nbin;
	int lang=zahl.GetLength();
	int komma=zahl.Find(',');
	if (komma==-1){komma=zahl.Find('.');}
	if(komma==-1)
	{ vkanz=lang;nkanz=0; }
	else
	{ 
	if(komma==0){vkanz=0;nkanz=lang-1;}
	else{vkanz=komma;nkanz=lang-(komma+1);}
	}
	if(vkanz>0){vk=new int[vkanz];vbin=new CString[vkanz];}
	if(nkanz>0){nk=new int[nkanz];nbin=new CString[nkanz];}
	CString nursov;CString nurson;CString vork=zahl.Left(vkanz);CString nachk=zahl.Right(nkanz);
	for(int x=0;x<vkanz;x++)
	{
		switch(vork.GetAt(x))
		{
		case '0':vk[x]=0;vbin[x]="0000 ";break;
		case '1':vk[x]=1;vbin[x]="0001 ";break;
		case '2':vk[x]=2;vbin[x]="0010 ";break;
		case '3':vk[x]=3;vbin[x]="0011 ";break;
		case '4':vk[x]=4;vbin[x]="0100 ";break;
		case '5':vk[x]=5;vbin[x]="0101 ";break;
		case '6':vk[x]=6;vbin[x]="0110 ";break;
		case '7':vk[x]=7;vbin[x]="0111 ";break;
		case '8':vk[x]=8;vbin[x]="1000 ";break;
		case '9':vk[x]=9;vbin[x]="1001 ";break;
		case 'A':vk[x]=10;vbin[x]="1010 ";break;
		case 'B':vk[x]=11;vbin[x]="1011 ";break;
		case 'C':vk[x]=12;vbin[x]="1100 ";break;
		case 'D':vk[x]=13;vbin[x]="1101 ";break;
		case 'E':vk[x]=14;vbin[x]="1110 ";break;
		case 'F':vk[x]=15;vbin[x]="1111 ";break;
		default:break;
		}
		nursov+=vbin[x];
	}
	for(x=0;x<nkanz;x++)
	{
		switch(nachk.GetAt(x))
		{
		case '0':nk[x]=0;nbin[x]="0000 ";break;//mit ?
		case '1':nk[x]=1;nbin[x]="0001 ";break;
		case '2':nk[x]=2;nbin[x]="0010 ";break;
		case '3':nk[x]=3;nbin[x]="0011 ";break;
		case '4':nk[x]=4;nbin[x]="0100 ";break;
		case '5':nk[x]=5;nbin[x]="0101 ";break;
		case '6':nk[x]=6;nbin[x]="0110 ";break;
		case '7':nk[x]=7;nbin[x]="0111 ";break;
		case '8':nk[x]=8;nbin[x]="1000 ";break;
		case '9':nk[x]=9;nbin[x]="1001 ";break;
		case 'A':nk[x]=10;nbin[x]="1010 ";break;
		case 'B':nk[x]=11;nbin[x]="1011 ";break;
		case 'C':nk[x]=12;nbin[x]="1100 ";break;
		case 'D':nk[x]=13;nbin[x]="1101 ";break;
		case 'E':nk[x]=14;nbin[x]="1110 ";break;
		case 'F':nk[x]=15;nbin[x]="1111 ";break;
		default:break;
		}
		nurson+=nbin[x];
	}
	m_bini=nursov;
	m_bini+=", ";
	m_bini+=nurson;
	int z=16;int a=0;int d=vkanz-1;x=-1;//letze nur sich selbst vorletzte 16 dann 256
	for(d;d>-1;d--)
	{	//vk[d]=vk[d]+(x*pow(16,16));
		//if(x<0){vk[d]=vk[d];}
		//if(x==0){vk[d]=vk[d]*16;}
		//if(x>0) {vk[d]=vk[d]*(x*(16*16));}
		switch(x)
		{
		case -1:vk[d]=vk[d];break;
		case 0 :vk[d]=vk[d]*16;break;
		case 1:vk[d]=vk[d]*(16*16);break;
		case 2:vk[d]=vk[d]*(16*16*16);break;
		case 3:vk[d]=vk[d]*(16*16*16*16);break;
		case 4:vk[d]=vk[d]*(16*16*16*16*16);break;
		case 5:vk[d]=vk[d]*(16*16*16*16*16*16);break;
		case 6:vk[d]=vk[d]*(16*16*16*16*16*16*16);break;
		case 7:vk[d]=vk[d]*(16*16*16*16*16*16*16*16);break;
		case 8:vk[d]=vk[d]*(16*16*16*16*16*16*16*16*16);break;
		case 9:vk[d]=vk[d]*(16*16*16*16*16*16*16*16*16*16);break;
		case 10:vk[d]=vk[d]*(16*16*16*16*16*16*16*16*16*16*16);break;
		case 11:vk[d]=vk[d]*(16*16*16*16*16*16*16*16*16*16*16*16);break;
		case 12:vk[d]=vk[d]*(16*16*16*16*16*16*16*16*16*16*16*16*16);break;
		default:break;
		}
		
		
		x++;
	}
	a=0;
	for(x=0;x<vkanz;x++)
	{ a=a+vk[x];}
	char bse[10];
	itoa(a,bse,10);m_deci=bse;
	UpdateData(FALSE);
	d=0;x=0;double nachkomma=0.0;double neu;//x=0 statt -1
	for(d;d<nkanz;d++)
	{
		neu=nk[d];
		//if(x<0){nachkomma=neu;}
		//if(x==0){nachkomma=nachkomma+(neu/16);}
		//if(x>0){nachkomma=nachkomma+(neu/(x*(16*16)));}
		switch(x)
		{
		case -1:nachkomma=neu;break;
		case 0 :nachkomma=neu/16;break;
		case 1:nachkomma=nachkomma+(neu/(16*16));break;
		case 2:nachkomma=nachkomma+(neu/(16*16*16));break;
		case 3:nachkomma=nachkomma+(neu/(16*16*16*16));break;
		case 4:nachkomma=nachkomma+(neu/(16*16*16*16*16));break;
		case 5:nachkomma=nachkomma+(neu/(16*16*16*16*16*16));break;
		case 6:nachkomma=nachkomma+(neu/(16*16*16*16*16*16*16));break;
		case 7:nachkomma=nachkomma+(neu/(16*16*16*16*16*16*16*16));break;
		case 8:nachkomma=nachkomma+(neu/(16*16*16*16*16*16*16*16*16));break;
		case 9:nachkomma=nachkomma+(neu/(16*16*16*16*16*16*16*16*16*16));break;
		case 10:nachkomma=nachkomma+(neu/(16*16*16*16*16*16*16*16*16*16*16));break;
		case 11:nachkomma=nachkomma+(neu/(16*16*16*16*16*16*16*16*16*16*16*16));break;
		case 12:nachkomma=nachkomma+(neu/(16*16*16*16*16*16*16*16*16*16*16*16*16));break;
		default:break;
		}

		x++;
	}
	char *container;int decimal;int sign;int precision = 10;
	container=_ecvt(nachkomma, precision, &decimal, &sign );
	m_deci+=",";
	m_deci+=container;
	UpdateData(FALSE);
	//jetzt noch die hex nachkomma stellen
	if(vkanz>0){delete[] vk;delete[] vbin;}
	if(nkanz>0){delete[] nk;delete[] nbin;}
}


void CConvertitDlg::dual()
{

	int vkanz=0;int nkanz=0;
	CString zahl=m_wert;
	CString *vbin;CString *nbin;
	int lang=zahl.GetLength();
	int komma=zahl.Find(',');
	if (komma==-1){komma=zahl.Find('.');}
	if(komma==-1)
	{ vkanz=lang;nkanz=0; }
	else
	{ 
	if(komma==0){vkanz=0;nkanz=lang-1;}
	else{vkanz=komma;nkanz=lang-(komma+1);}
	}
	double test=0.0;int erg=0;int vk=0;int nk=0;
	//plausibilitaet für die anzahl der Stellen
	if (vkanz>0){test=vkanz;test=test/4;erg=test;test=test-erg;}
	if(test!=0){AfxMessageBox("Die Anzahl der Vorkomma stellen stimmt nicht");return;}
	if (nkanz>0){test=nkanz;test=test/4;erg=test;test=test-erg;}
	if(test!=0){AfxMessageBox("Die Anzahl der Nachkomma stellen stimmt nicht");return;}
	
	if(vkanz>0){test=vkanz;test=test/4;erg=test;vbin=new CString[erg];vk=erg;}
	if(nkanz>0){test=nkanz;test=test/4;erg=test;nbin=new CString[nkanz/4];nk=erg;}
	CString vork=zahl.Left(vkanz);CString nachk=zahl.Right(nkanz);
	int d=0;
	for(int x=0;x<vkanz;d++)
	{
		for(int y=1;y<5;y++)
		{
			if(y==1){vbin[d]=vork.GetAt(x);}
			else {vbin[d]+=vork.GetAt(x);}
			x++;
		}
		
	}
	d=0;
	for(x=0;x<nkanz;d++)
	{
		for(int y=1;y<5;y++)
		{
			if(y==1){nbin[d]=nachk.GetAt(x);}
			else {nbin[d]+=nachk.GetAt(x);}
			x++;
		}
		
	}
	m_wert="";
	for(x=0;x<vk;x++)
	{
		if(vbin[x]=="0000"){vbin[x]="0";}
		if(vbin[x]=="0001"){vbin[x]="1";}
		if(vbin[x]=="0010"){vbin[x]="2";}
		if(vbin[x]=="0011"){vbin[x]="3";}
		if(vbin[x]=="0100"){vbin[x]="4";}
		if(vbin[x]=="0101"){vbin[x]="5";}
		if(vbin[x]=="0110"){vbin[x]="6";}
		if(vbin[x]=="0111"){vbin[x]="7";}
		if(vbin[x]=="1000"){vbin[x]="8";}
		if(vbin[x]=="1001"){vbin[x]="9";}
		if(vbin[x]=="1010"){vbin[x]="A";}
		if(vbin[x]=="1011"){vbin[x]="B";}
		if(vbin[x]=="1100"){vbin[x]="C";}
		if(vbin[x]=="1101"){vbin[x]="D";}
		if(vbin[x]=="1110"){vbin[x]="E";}
		if(vbin[x]=="1111"){vbin[x]="F";}
		m_wert+=vbin[x];
	}
	if(nk>0){m_wert+=",";}
	for(x=0;x<nk;x++)
	{
		if(nbin[x]=="0000"){nbin[x]="0";}
		if(nbin[x]=="0001"){nbin[x]="1";}
		if(nbin[x]=="0010"){nbin[x]="2";}
		if(nbin[x]=="0011"){nbin[x]="3";}
		if(nbin[x]=="0100"){nbin[x]="4";}
		if(nbin[x]=="0101"){nbin[x]="5";}
		if(nbin[x]=="0110"){nbin[x]="6";}
		if(nbin[x]=="0111"){nbin[x]="7";}
		if(nbin[x]=="1000"){nbin[x]="8";}
		if(nbin[x]=="1001"){nbin[x]="9";}
		if(nbin[x]=="1010"){nbin[x]="A";}
		if(nbin[x]=="1011"){nbin[x]="B";}
		if(nbin[x]=="1100"){nbin[x]="C";}
		if(nbin[x]=="1101"){nbin[x]="D";}
		if(nbin[x]=="1110"){nbin[x]="E";}
		if(nbin[x]=="1111"){nbin[x]="F";}
		m_wert+=nbin[x];
	}
	hexi();
	m_wert=zahl;
	UpdateData(FALSE);


	//m_bini=m_wert;
	UpdateData(FALSE);
	if(vkanz>0){delete[] vbin;}
	if(nkanz>0){delete[] nbin;}

}

//plausibilitaetsprüfungen der Eingabe


bool CConvertitDlg::plausi(int x)
{	
	int y=0;
	bool ok=true;
	CString zahl=m_wert;
	int lang=zahl.GetLength();
	switch (x)
	{
	case 1: 
		for(y=0;y<lang;y++)
		{
			switch(zahl.GetAt(y))
			{
			case '1':break;
			case '2':break;
			case '3':break;
			case '4':break;
			case '5':break;
			case '6':break;
			case '7':break;
			case '8':break;
			case '9':break;
			case '0':break;
			case '.':break;
			case ',':break;
			default:ok=FALSE;return false;break;
			}
		}
		break;
	case 2:
		for(y=0;y<lang;y++)
		{
			switch(zahl.GetAt(y))
			{
			case '1':break;
			case '2':break;
			case '3':break;
			case '4':break;
			case '5':break;
			case '6':break;
			case '7':break;
			case '8':break;
			case '9':break;
			case '0':break;
			case '.':break;
			case ',':break;
			case 'A':break;
			case 'B':break;
			case 'C':break;
			case 'D':break;
			case 'E':break;
			case 'F':break;
			default:ok=FALSE;return false;break;
			}
		}
		break;
	case 3:
		for(y=0;y<lang;y++)
		{
			switch(zahl.GetAt(y))
			{
			case '1':break;
			case '0':break;
			case '.':break;
			case ',':break;
			default:ok=FALSE;return false;break;
			}
		}
		break;
	default:break;
	}
	return ok;

}
 
hi, ich hab nochma ne frage wegen der ausgabe:
//Zeilensprung und Ausgabe der Bits (von links nach rechts)
cout<<endl<<dual;

ich wollte es so machen das sich vierergruppen mit leerzeichen bilden
und zwar so:
als bsp: 0010 0000 1010 0001

ich bekomme das nicht genau hin, entweder er schreibt es untereineander oder gar nicht.
hoffe ihr könnt mir dazu noch einen tipp geben.

gruß
 
Du könntest entweder die bestimmten Bereiche mittels Schleifen ausgeben (fast genau wie im ersten Code).
 
Zuletzt bearbeitet:
Oben