# Dual in Dezimal und umgekehrt



## janwow1 (16. Januar 2013)

Hallo 
Ich hab versucht ein Programm zu schreiben das Dezimalzahlen in Dualzahlen umrechnet und umgekehrt. Ich hab leider keine Ahnung wie man eine Dualzahl in eine Dezimalzahl umwandeln kann und mein Programm jenes Dezimalzahlen in Dualzahlen wandelt funktioniert nicht wirklich..

#include <stdio.h>
#include <conio.h>


```
void main()
{
	int dZahl,bZahl,teiler=1,Rest;

	printf(" Dezimale Zahl: ");
	scanf("%d",&dZahl);

	while(dZahl>=teiler)
	{
		teiler=teiler*2;

	}
	teiler/=2;
	while(teiler<dZahl)
	{
		
		
		if(teiler<dZahl)
		{
		printf("1");
		dZahl=dZahl-teiler;
		
		}
		else
		{
			printf("0");
		}
		
		teiler=teiler/2;
		while(teiler>dZahl)
		{
			printf("0");
			teiler/=2;
		}
	}
	
	getch();


}
```


----------



## cwriter (16. Januar 2013)

Ein einfaches System?

Dezimalzahl % (modulo) 2. Z.B.

```
10 % 2 = 5 R 0
5 % 2 = 2 R 1
2 % 2 = 1 R 0
1 % 2 = 0 R 1
```

Ja, modulo liefert eigentlich nur den Rest. Ich habe es einfach mal anschaulicher dargestellt.
0101 muss man nun umkehren zu 1010.
Schreibe die Moduloergebnisse also in einen char array und lies diesen nacher _rückwärts_ aus.

Gruss
cwriter

//EDIT: http://webpixelpromoter.com/2011/informatik/binar-zahlen-dezimal-zahlen-umrechnen/ <- der hier erklärt das ganze noch etwas besser


----------



## H4ckHunt3r (26. Januar 2013)

Ein wenig Performanter würde es mit einer Bit-Schiebe operation gehen.

Hier mal ein Beispiel,
welches ich für die FH
schreiben musste:


```
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>


#define CHAR_BIT 8;

/*-----------------------------------------------------------------------------
 *  TYPE DEFINITIONS
 *-----------------------------------------------------------------------------*/
typedef char 			SmallSet;
typedef unsigned int 	uint;




/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  set_print
 *  Description:  Die Zahl in *s als Dualzahl ausgeben
 * =====================================================================================
 */
void set_print ( SmallSet *s, char *name )
{
	assert(s != NULL);

	printf("Menge %s: ", name);

	uint n = sizeof(SmallSet)*CHAR_BIT;
	uint mask = 1U<<(n-1);
	SmallSet x = *s;
	uint counter;

	for(counter = 0; counter < n; counter++)
	{
		if( (x & mask) != 0)
		{
			printf("1");
		}
		else
		{
			printf("0");
		}
		x <<= 1;
	}
	printf("\n");

}		/* -----  end of function set_print  ----- */





/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  main
 *  Description:  
 * =====================================================================================
 */
int main ( int argc, char *argv[] )
{


	
	/*-----------------------------------------------------------------------------
	 *  Testen der Funktionen
	 *-----------------------------------------------------------------------------*/
	SmallSet test = 16U; // U für Unsigned
	char *name = "test"; // name der Variablen

	set_print(&test, name);

	return EXIT_SUCCESS;
}				/* ----------  end of function main  ---------- */
```

Das ganze kannst du natürlich auch für int benutzen statt für char wenn du größere Zahlen brauchst.
Dafür musst du oben in der typ definition das char zu int machen.


Hoffe das Hilft dir.


----------



## Cromon (26. Januar 2013)

Hallo H4ckHunt3r,

Dein Programm hat ein Problem:

```
uint n = sizeof(SmallSet)*CHAR_BIT;
```

n ist in diesem Fall sizeof(pointer) * CHAR_BIT was auf 32 Bit Systemen immer 32 ergibt (da sizeof(pointer) da 4 ist und CHAR_BIT 8), auf 64 Bit Systemen 64 (da sizeof(pointer) 8 ist). Was ist die Überlegung dahinter?

Grüsse
Cromon


----------



## H4ckHunt3r (26. Januar 2013)

```
typedef char            SmallSet;
```

nein es ist die größe von einem char 

Da sizeof bytes zurück gibt = 1
das mal 8 = 8bit^^


wenn da stehen würde 

```
sizeof(s)
```
dann hättest du recht.


denn s ist ein pointer der auf einen wert vom typ SmallSet (hier char) zeigt.


----------



## Cromon (26. Januar 2013)

Stimmt, ich mag solche wilden Typedefs nicht, da verwechselt man immer was jetzt Typ was Variable oder sonst was ist .


----------



## H4ckHunt3r (26. Januar 2013)

Cromon hat gesagt.:


> Stimmt, ich mag solche wilden Typedefs nicht, da verwechselt man immer was jetzt Typ was Variable oder sonst was ist .



In dem Fall wurde es gemacht um es schnell ändern zu können da das Programm eigentlich 12 Funktionen enthält und es lästig wäre den Typ überall ändern zu müssen.^^

So und nu back2topic..^^


----------



## H4ckHunt3r (28. Januar 2013)

So, mir war gerade langweilig.
Deshalb hier die komplettlösung für das Umwandeln in beide richtungen:


```
/*
 * =====================================================================================
 *
 *       Filename:  binaer_dezimal.c
 *
 *    Description:  Binär in Dezimal und andersherum umrechnen.
 *
 *        Version:  1.0
 *        Created:  28.01.2013 18:16:20
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  H4ckHunt3r
 *
 *   	 Webseite: www.h4ckhunt3r.net
 *   		  ICQ: 58-92-35
 *   		Skype: h4ckhunt3rnet
 *
 * =====================================================================================
 */
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>

#define BIN_SIZE 32


/*-----------------------------------------------------------------------------
 *  TYPE DEFINITIONS
 *-----------------------------------------------------------------------------*/
typedef _Bool 				bin;
typedef unsigned int 		uint;


/*-----------------------------------------------------------------------------
 *  FUNCTION PROTOTYPES
 *-----------------------------------------------------------------------------*/
void 	int_to_bin(uint *i, bin b[]);
void 	bin_to_int(bin b[], uint *i);
void 	print_bin(bin b[]);
uint 	power ( uint x, uint n );


/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  main
 *  Description:  Hauptprogramm
 * =====================================================================================
 */
int main ( int argc, char *argv[] )
{
	uint 	exp_int = 327;
	bin 	exp_int_bin[BIN_SIZE] = {0};

	bin 	exp_bin[BIN_SIZE] = {0};
	        exp_bin[3] = 1;
	uint	exp_bin_int = 0;

	printf("%20s %u\n", "exp_int:", exp_int);
	int_to_bin(&exp_int, exp_int_bin);
	printf("%20s ", "exp_int -> bin:");
	print_bin(exp_int_bin);

	printf("%20s ", "exp_bin:");
	print_bin(exp_bin);
	bin_to_int(exp_bin, &exp_bin_int);
	printf("%20s %u\n", "exp_bin -> int:", exp_bin_int);


	return EXIT_SUCCESS;
}				/* ----------  end of function main  ---------- */



/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  print_bin
 *  Description:  Binärzahl ausgeben
 * =====================================================================================
 */
void 	print_bin(bin b[])
{
	assert(b != NULL);

	uint counter;

	for(counter = 0; counter < BIN_SIZE; counter++)
	{
		printf("%d", (int)b[counter]);
		if( (counter+1)%4 == 0) printf(" ");
	}
	printf("\n");
}



/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  int_to_bin
 *  Description:  Ganzzahl (Dezimal) in Binärzahl umwandeln
 * =====================================================================================
 */
void 	int_to_bin(uint *i, bin b[])
{
	assert(i != NULL);
	assert(b != NULL);

	uint mask = 1U;

	uint x = *i;
	uint counter;

	for(counter = 0; counter < BIN_SIZE; counter++)
	{
		if( (x & mask) != 0 )
		{
			b[(BIN_SIZE - counter)-1] = 1;
		}
		else
		{
			b[(BIN_SIZE - counter)-1] = 0;
		}
		mask <<= 1;
	}

}				/* ----------  end of function int_to_bin  ---------- */




/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  bin_to_int
 *  Description:  Binärzahl zu Ganzzahl (Dezimal) umwandeln
 * =====================================================================================
 */
void 	bin_to_int(bin b[], uint *i)
{
	assert(b != NULL);
	assert(i != NULL);

	uint counter;
	uint erg = 0;

	for(counter = 0; counter < BIN_SIZE; counter++)
	{
		erg += b[(BIN_SIZE - counter)-1] * power(2, counter);
	}

	*i = erg;
}



/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  power
 *  Description:  Potenzieren von Ganzzahlen
 *    Parameter:	x: Basis	(Ganzzahl)
 *    				n: Exponent (Ganzzahl)
 * =====================================================================================
 */
uint	power ( uint x, uint n )
{
	uint erg = 1;

	while ( n != 0 )
	{
		if(n % 2)
		{
			erg *= x;
		}
		n /= 2;
		x *= x;
	}

	return erg;
}		/* -----  end of function power  ----- */
```




Viel Spaß damit.
Bei fragen, stehe ich natürlich gerne zur verfügung..


----------



## Ferdi01 (23. Januar 2021)

hallo, hab euer Programm angeschaut und wollte es erweitern hab aber ein Problem: Wie kann ich ein char* in ein SmallSet* konvertieren, damit ich es in die Funktion übergeben kann. Hier ist nun mein erweitertes Programm.

```
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <cstring>

/*-----------------------------------------------------------------------------
*  TYPE DEFINITIONS
*-----------------------------------------------------------------------------*/
typedef char             SmallSet;
typedef unsigned int     uint;
int char_bit=8;

char retbin[20];


/*
* ===  FUNCTION  ======================================================================
*         Name:  set_print
*  Description:  Die Zahl in *s als Dualzahl ausgeben
* =====================================================================================
*/
char* set_print ( SmallSet *s, int char_bit)
{
    assert(s != NULL);

    uint n = sizeof(SmallSet)*char_bit;
    uint mask = 1U<<(n-1);
    SmallSet x = *s;
    uint counter;

    for(counter = 0; counter < n; counter++)
    {
        if( (x & mask) != 0)
        {
            retbin[counter] = '1';
        }
        else
        {
            retbin[counter] = '0';
        }
        x <<= 1;
    }
    return retbin;

}        /* -----  end of function set_print  ----- */





/*
* ===  FUNCTION  ======================================================================
*         Name:  main
*  Description:
* =====================================================================================
*/
int main ( int argc, char *argv[] )
{

    char buffer[10] = ""; 
    printf("\nGib eine Zahl ein:");
    fgets(buffer, 10, stdin);
    fflush(stdin);
    int test=atoi(buffer);

    mybin = set_print(&test,char_bit);
    printf("%s\n",mybin);

    return EXIT_SUCCESS;
}
```
Danke, wenn ihr mir helfen könnt.


----------

