bits von int* feld abtrennen

uwerothfeld

hallo zusammen,

ich habe ein kleines problem, welches bestimmt total einfach ist, aber ich einfach nicht gelöst bekomme. ich benötige eine funktion, welche aus einen interger feld (int* data) die ersten X bits ausliest bzw. abtrennt und diese als int zurückliefert. ich habe etwas in der art versucht (hiermal für die ersten 2 bit):

int trenne(int* data){

  int result = 0;

  result = *data << 1;
  data++;
  result = *data << 1;
  data++;

  return result;
}

geht aber leider überhaupt nicht, die ganze schosse. jemand einen tip?

vielen dank schonmal.

mfg

uwe

wie viele bits sollen es denn maximal werden?

CStoll

Erstmal - das unterste Bit einer int-Zahl erhältst du mit "wert & 1", die nächsthöheren Bits mit "(wert & (1<<n))>>n".

Zweitens: Willst du aufeinanderfolge Bits des Arrays auslesen und verarbeiten - oder willst du aus jedem int-Element das unterste Bit rausziehen?

(edit: natürlich sollte man auch den richtigen Operator verwenden *duck'n'run*)

CStoll schrieb:

Erstmal - das unterste Bit einer int-Zahl erhältst du mit "wert | 1"

'wert & 1'. das '|' setzt bits auf 1.

uwerothfeld

Hallo zusammen,

also das ging ja schnell. Toll! Echt super. Zu meinem Problem: Also ich habe ein Netzwerknachricht, welche ein data Feld als Element enthält. Dies ist vom Type int[]. Diese bekomme ich als int* data. Nun muß ich dieses Feld bitweise auslesen. Dazu will ich diese Funktion. In einen Fall will ich zum Beispiel zwei Bit abarbeiten, dann wieder vier und so weiter. Die Bits sollen dann als int Zahl zurück gegeben werden.

Wäre toll wenn ihr mir sagen könntet wie es geht. Danke schon mal.

uwe

CStoll schrieb:

Erstmal - das unterste Bit einer int-Zahl erhältst du mit "wert | 1"

das wäre einem erfahrenen programmierer aber nicht passiert.

nagut, du könntest es so machen:

int get_num( int* pi, int pos, int n )
{
	int res = 0;
	int i = 0;

	if( n >  ( sizeof(int)*8) )
	{
		puts("Sorry no bonus!");
		puts(":-(");
		exit(1);
	}

	for ( i=0; i<n; i++ )
	{
		if ( pi[pos/(sizeof(int)*8)] & ( 1 << ((pos%32)+i) ))
				res |= (1 << ((pos%32)+i));
	}
	return res;
}

n steht für die anzahl der bits, die du abfragen willst. pos ist die postion des bits im array, wo die abfrage beginnt.

CStoll schrieb:

Erstmal - das unterste Bit einer int-Zahl erhältst du mit "wert | 1"

das wäre einem erfahrenen programmierer aber nicht passiert.

nagut, du könntest es so machen:

int get_num( int* pi, int pos, int n )
{
	int res = 0;
	int i = 0;

	if( n >  ( sizeof(int)*8) )
	{
		puts("Sorry no bonus!");
		puts(":-(");
		exit(1);
	}

	for ( i=0; i<n; i++ )
	{
		if ( pi[pos/(sizeof(int)*8)] & ( 1 << ((pos%32)+i) ))
				res |= (1 << ((pos%32)+i));
	}
	return res;
}

n steht für die anzahl der bits, die du abfragen willst. pos ist die postion des bits im array, wo die abfrage beginnt.

sorry for doppelposting, aber dat forum dingen hat mir igendnen php mail fehler angezeigt.

mfg
s.n.b.a.a

CStoll

sorry no bonus schrieb:

CStoll schrieb:

Erstmal - das unterste Bit einer int-Zahl erhältst du mit "wert | 1"

das wäre einem erfahrenen programmierer aber nicht passiert.

Du gehörst wohl zu der Kategorie Super-Programmierer, die in C denken?

Ansonsten zu deinem Quelltext: Du solltest dich mal entscheiden, ob du die Größe von int berechnet (wenn, dann bitte als "sizeof(int)*CHAR_BITS") oder als Konstante 32 verwenden willst

uwerothfeld

Hallo zusammen,

ich habe es getestet und es ist wirklich supi. wäre ich wohl so nie drauf gekommen. bei der bit schieberei habe ich immer ein brett vor dem kopf. von daher erst einmal danke. nun dennoch zwei fragen:

wenn ich sowas wie ein z.b. unint8 habe (unsigned int, 8 bit lang) dann muß ich doch nur die entsprechenden %32 anweisungen dagegen austauschen. richtig? oder?
wie behandle ich bitfolgen die über die grenzen feldern verlaufen und ich aber als einheit betrachten will? beispiel:

ich habe mein int feld mit dem index 0, brauche aber aus diesem ab dem 6. bit die nächsten vier bit.

[00 01 00 11 | 11 00 10 00 | ... ]

also 1111, dies scheitert ja jetzt. muß ich dann erst die letzten zwei auslesen und dann die ersten zwei aus dem nächsten index und diese zusammenfügen? wie mach ich das? also sozusagen aus int a und int b will ich einen int ab machen.
die anweisung

pi[pos/(sizeof(int)*8)]

wählt doch sozusagen modulo 256 den index innerhalb des feldes pi, könnte ich dann auch mit

( 1 << ((pos%32)+i) )

über die grenzen weglesen? also wenn i größer als die hier angenommenen 32bit pro int ist? also das ich halt in den nächsten index reinlese?

Gruß und mit großen Dank

Uwe

danke.

uwerothfeld schrieb:

Hallo zusammen,

ich habe es getestet und es ist wirklich supi. wäre ich wohl so nie drauf gekommen. bei der bit schieberei habe ich immer ein brett vor dem kopf. von daher erst einmal danke. nun dennoch zwei fragen:

wenn ich sowas wie ein z.b. unint8 habe (unsigned int, 8 bit lang) dann muß ich doch nur die entsprechenden %32 anweisungen dagegen austauschen. richtig? oder?

Ja.
Anstat pos%32 hätte ich lieber pos%(sizeof(int)*8) schreiben sollen. Ggf. kannst du int durch unint8 etc. austauschen.
Ein Byte ist ja pratisch immer 8 Bit, ansonsten kannst du die 8 ja auch variabel machen.

uwerothfeld schrieb:

wie behandle ich bitfolgen die über die grenzen feldern verlaufen und ich aber als einheit betrachten will?

Du kannst so viele Index-Grenzen überspringen, wie du möchtest.
Voraussetzung ist, das der Datentyp des Rückgabewertes entsprechend gross ist und natürlich muss auch das Array gross genug sein.
Die Anzahl der abzufragenden Bits, hier also n, darf auch nicht größer als die Anzahl Bits des Rückgabetypen werden. Es ist also:
n <= ( sizeof( "dein datentyp" ) * "deine bits/byte" )
einzuhalten.

uwerothfeld

hallo zusammen,

also ich wollt nochmal danken. ich mußte zwar noch ein wenig fummeln da doch alles ein wenig anders sein sollte als ich erst dachte, aber nun hat es funktioniert. sehr schön. vielen dank. tolles forum.

gruß

uwe