Binär hochzählen / Links,Rechts schieben

Samuirai

Hallo,

ich stehe vor folgendem Problem.
Ich speichere in einem Objektarray ein Array als Attribut mit n Elementen.
Vereinfacht kann man sagen:

obj[0] = 0,0,0
obj[1] = 0,0,1
obj[2] = 0,1,0
obj[3] = 0,1,1
...

Ich bin nicht so fitt in speziellen Funktionen, aber ich habe mal bei einem
Freund gesehen, wie er eine Ganzzahl mit << und >> immer Stellenweise nach rechts/links geschoben hat.
Irgendwie so:

zahl=123;
n << zahl;
n == 1;

Bin mir aber nicht mehr genau sicher.
Wenn es so möglich wäre, hab ich gedacht, dass man vllt mit einer einfachen Funktion aus einer Dezimalzahl die Binärzahl machen kann, und dann diese einzelnen Bits durch schieben erhalte.

Oder habt ihr bessere Tipps?
Der Code sollte schon recht schnell sein und dachte, dass dieses schieben sehr low Level läuft.

Tut mir leid wenn ich unsinnige Fragen stelle, ich bin kein Experte

Ich hoffe jemand kann mir helfen,
Viele Grüße,

Samuirai

Samuirai schrieb:

Hallo,

ich stehe vor folgendem Problem.
Ich speichere in einem Objektarray ein Array als Attribut mit n Elementen.
Vereinfacht kann man sagen:

obj[0] = 0,0,0
obj[1] = 0,0,1
obj[2] = 0,1,0
obj[3] = 0,1,1
...

Ich bin nicht so fitt in speziellen Funktionen, aber ich habe mal bei einem
Freund gesehen, wie er eine Ganzzahl mit << und >> immer Stellenweise nach rechts/links geschoben hat.
Irgendwie so:

zahl=123;
n << zahl;
n == 1;

Bin mir aber nicht mehr genau sicher.
Wenn es so möglich wäre, hab ich gedacht, dass man vllt mit einer einfachen Funktion aus einer Dezimalzahl die Binärzahl machen kann, und dann diese einzelnen Bits durch schieben erhalte.

Oder habt ihr bessere Tipps?
Der Code sollte schon recht schnell sein und dachte, dass dieses schieben sehr low Level läuft.

Tut mir leid wenn ich unsinnige Fragen stelle, ich bin kein Experte

Ich hoffe jemand kann mir helfen,
Viele Grüße,

Samuirai

Durch solche Optimierungen erhältst du in der Regel keine Vorteile. Dein Compiler ist intelligent genug entsprechende Optimierungen selber vorzunehmen, falls diese tatsächlich Sinn machen.

schlaue leute nehmen auch unions

DocShoe

dgrat schrieb:

schlaue leute nehmen auch unions

Ganz schlaue Leute nehmen keine Unions, da das Speicherlayout von unions nicht durch den Standard vorgeschrieben wird.

volkard

Vermutlich ist es schon eine Schnapsidee, sowas

obj[3] = 0,1,1

zu machen.

wxSkip

Wenn ich dich recht erhalten habe, willst du also eine Binärzahl aus einer Dezimalzahl erhalten.
Wenn du beispielsweise die Binärzahl in einem std::string speichern willst, wie wär's mit:

short y;
cin >> y;
std::stringstream str;
str << y & 8192;
str << y & 4096;
str << y & 2048;
str << y & 1024;
str << y & 512;
str << y & 256;
str << y & 128;
str << y & 64;
str << y & 32;
str << y & 16;
str << y & 8;
str << y & 4;
str << y & 2;
str << y & 1;
std::string binaercode = str.str()

(ungetestet und unschön, aber nur um das Prinzip klarzustellen)

Oder mit std::bitset :

int input; // kann selbstverständlich angepasst werden 
do
{
	std::cin.clear();
	std::cin.ignore(std::cin.rdbuf()->in_avail());
	std::cout << "Zahl eingeben: ";
} while(!(std::cin >> input)); /* so lange wiederholen, bis gültige Eingabe vorliegt */
std::bitset<32> bits(input);
std::cout << input << " --> " << bits.to_string();

DocShoe schrieb:

dgrat schrieb:

schlaue leute nehmen auch unions

Ganz schlaue Leute nehmen keine Unions, da das Speicherlayout von unions nicht durch den Standard vorgeschrieben wird.

muss es auch nicht.

Samuirai

@volkard
das war nur ein vereinfachtest Beispiel. Für das was ich benötige ist es nicht wichtig wie das Objekt aussieht, wollte damit nur verdeutlichen, dass darin die Binärzahlen gespeichert werden.

Ich habe jetzt eine eigene Lösung gefunden:

// binaer:		Die Binaerzahl die für alle Kombinationen benötigt wird, also 0,1,2,3,... -> 00,01,10,11,...
		unsigned long binaer = i;
		// bina:		Zählt in 2er Potenzen hoch indem das 1er Bit immer um eins weitergeschoben wird
		unsigned int bina = 1;
		// arr:			arr wird die Bitkombinationen enthalten: 0,0,0 / 0,0,1 / 0,1,0 / ...
		int arr[3] ={0};

		for(int j=0; j<3; j++)
		{
			// Ver-UND-en um die einzelnen Bits herauszufinden. 
			// Beispiel:
			// 101 soll in arr gespeichert werden
			//   101
			// & 001
			// -----
			//   001 !=0
			//
			//			bina weiterschieben 001 -> 010
			//
			//   101
			// & 010
			// -----
			//   000 ==0
			// ... usw
			if((binaer & bina) == 0)
			{
				arr[j] = 0;
			}
			else
			{
				arr[j] = 1;
			}

			// bina weiterschieben
			bina = bina << 1;
		}

Ich weiß nicht ob die Lösung unschön ist oder nicht, aber sie tut das was ich brauche. Ich wusste nicht, dass man in C++ Verunden und Schieben (Shift) kann.

Vielen Dank an Alle, die sich um eine Lösung bemüht haben

Viele Grüße,
Samuirai