Bit vertauschen

Zulooo schrieb:

Hey, wie kann ich das n-te Bit der Variable a mit dem m-ten Bit der Variable b tauschen?
...
Wie geht das?

Wenn die zu tauschenden Bits gleich sind, braucht man sie nicht zu tauschen, stimmt's ?
Sind diese Bits ungleich, toggelt man sie und fertig!

void swapBit(int& var1, size_t pos1, int& var2, size_t pos2)
{
   if (((var1 >> pos1) & 1) != ((var2 >> pos2) & 1))
   {
		var1 ^= (1 << pos1);
		var2 ^= (1 << pos2);
   }
}

David_pb

So?

static inline int swapBit( int value, int i, int j )
{
	int swap = ( ( value >> i ) ^ ( value >> j ) ) & 1;
	return value ^ ( ( swap << i ) | ( swap << j ) );
}

David_pb schrieb:

So?

static inline int swapBit( int value, int i, int j )
{
	int swap = ( ( value >> i ) ^ ( value >> j ) ) & 1;
	return value ^ ( ( swap << i ) | ( swap << j ) );
}

So:

static inline int swapBit( int value, int i, int j )
{
    if (((value >> i) & 1) != ((value >> j) & 1))
		value ^= ((1 << i) | (1 << j));
	return value;
}

David_pb

otto8 schrieb:

So:

static inline int swapBit( int value, int i, int j )
{
    if (((value >> i) & 1) != ((value >> j) & 1))
		value ^= ((1 << i) | (1 << j));
	return value;
}

Auf keinen Fall! So:

static inline int swap( int value, int i, int j )
{
	return ( ( ( value >> i ) ^ ( value >> j ) ) & 1 )
		? value ^ ( ( 1 << i ) | ( 1 << j ) ) 
		: value;
}

Nexus

Eine Offtopic-Frage: Ist Code, der nach jedem Token ein Leerzeichen verwendet, wirklich so viel leserlicher als Code, der durchgehend ohne Leerzeichen auskommt?

volkard

Nexus schrieb:

Eine Offtopic-Frage: Ist Code, der nach jedem Token ein Leerzeichen verwendet, wirklich so viel leserlicher als Code, der durchgehend ohne Leerzeichen auskommt?

Sharp oder IBM?
Manche machen auch nach jeder Zeile eine Leerzeile, außer da, wo ich statt der zwei zusammegehörenden Zeilen lieber bloß eine geschrieben hätte.

drakon

Nexus schrieb:

Eine Offtopic-Frage: Ist Code, der nach jedem Token ein Leerzeichen verwendet, wirklich so viel leserlicher als Code, der durchgehend ohne Leerzeichen auskommt?

Ich finde oftmals ja. In einer Situation, wie oben muss man den Ausdruck eh recht genau anschauen, wenn man mit den Klammern nicht durcheinander kommen will, aber ich mache auch gerne Abstände, damit ich den Code nicht lesen, sondern nur anschauen muss. Wenn jetzt alles zusammen klebt übersehe ich leicht eine Klammer oder ein Zeichen o.ä.

Ich grupiere auch gerne Anweisungen, wie volkard anspricht. Jetzt nicht prinzipiell nach jeder Zeile ein Abstand, aber wenn ich 3-4 Aufrufe z.B auf das gleiche Objekt habe, dann kommen die nache zu einander, Leerzeile und das anderere Anweisungen.

foo.f ();
foo.bar ();
foo.foobar ();

baz.foo ();
baz.bar ();

Nexus

Natürlich ist es sinnvoll, Abstände zu benutzen. In meinen Augen tragen Whitespaces jedoch besonders dann zur Übersicht bei, wenn man sie unterschiedlich stark einsetzt.

(7*x - 3*y + 5) / (4*x + 5*y - 8)

Anweisungen zeilenweise gruppieren tue ich auch. Aber eben, auf diese Weise werden Newlines wieder mit Mass verwendet.

drakon schrieb:

foo.f ();
foo.bar ();
foo.foobar ();

baz.foo ();
baz.bar ();

da könntest doch auch schon fast über chaining nachdenken

foo.f().bar().foobar();
baz.foo().bar();

evtl. gehts auch nur so

foo->f()->bar()->foobar();
baz->foo()->bar();

Nexus

Es ginge schon beides, abhängig davon, ob eine Referenz oder ein Zeiger zurückgegeben würde.

Chaining ist im Grunde genommen eine interessante Technik, aber in vielen Fällen macht sie den Code nur noch unübersichtlicher. Denn weniger Zeilen ist nicht unbedingt besser.

image.set_size(22, 13).set_background_color(color::green).set_rotation(15.5f);
// vs.
image.set_size(22, 13)
image.set_background_color(color::green)
image.set_rotation(15.5f);

volkard

Test:

z = (7*x - 3*y + 5) / (4*x + 5*y - 8)

z = (7*x-3*y+5) / (4*x+5*y-8)

z=(7*x-3*y+5)/(4*x+5*y-8)

z= (7*x - 3*y + 5) 
   /
   (4*x + 5*y - 8)

also den größten flächeninhalt hat das letzte

Nexus

Kompromiss?

z = (7*x - 3*y + 5) 
  / (4*x + 5*y - 8);

Aber das mache ich eigentlich eher selten. Kommt ja auch nicht allzu häufig vor, dass man Teilausdrücke einander so schön zuordnen kann. Was ich manchmal bei komplexeren Ausdrücken mache:

foo.bar(
    vector2(
        32.5f + random(-4.f, 4.f) - 25.8f*foo.bir(),
        66.7f),
    124.4f - random(3.f, 7.f)/foo.bor(),
    "a string");

Ich muss allerdings gestehen, dass ich Abstände bei verschiedenen Operatoren nicht immer ganz strikt handhabe. Ich habe diesbezüglich noch kein Optimum gefunden, das man verallgemeinern könnte.

foo.bar(
    vector2(
        32.5f+random(-4.f,4.f)-25.8f*foo.bir()
       ,66.7f
    )
    ,124.4f-random(3.f,7.f)/foo.bor()
    ,"a string"
);

drakon

Chaining kann man machen, aber das macht imo nur dort Sinn, wo von einer Klasse wirklich ein solchen sehr intensives benutzen von einfachen Funktionen erwartet wird. (Hab das mal bei einer HTML Klasse oder so gesehen).

Ansonsten ist es wahrscheinlich Overkill dafür jeder Klasse eine Referenz auf sich selbt zurückgeben zu lassen, nur damit man das ev. mal machen kann. (Rückgabewerte kann man da ja auch nicht mehr so schön einbringen)

Bei volkards Beispiel würde ich die erste Variante bevorzugen.
In wirklichem Code würde wahrscheinlich die letzte Variante sehr merkwürdig aussehen..

fr33g

Leute ich kapier des mit den bits no net so ganz. Will jetzt zum bispiel flags setzen. Mach ich mir dann einfach eine char variable die ja 8 bit hat. So und dann muss ich gucken den buchstabe den ich der variable gebe welchem zahlenwert der entspricht und damm schaun wie davon die binäre zahl aussieht? Wenn ich dann genau das 4. Bit ändern will muss ich dass ja mit und oder oder so machen. Und wie kann ich dann z.b abfragen ob genau das 4. Bit true ist?

Danke schonmal;-)

Fellhuhn

Warum nicht einfach std::bitset verwenden?

// Bits:
std::bitset<32> myBits;

// Bits vertauschen:
std::swap(myBits[3], myBits[5]);

// Abfragen:
if (myBits.test(4)) ...

Warum immer kompliziert?

char a = 0;      // kein Bit gesetzt (Bit 0 bis 7 == 0)

    a = (a | 1<<3);  // Bit 3 setzen ( or )
    a = (a ^ 1<<3);  // Bit 3 umkippen (toggeln) (xor) ist nun wieder 0  
    a = (a & 1<<3);  // Bit 3 testen (and) ist 0
    a = (a ^ 1<<3);  // Bit 3 toggle (xor) ist nun 1
    a = (a & 1<<3);  // Bit 3 testen (and) ist 1
    a = (a & ~(1<<3)); // Bit 3 loeschen

Carstig

@Fellhuhn: ich mag deine Antwort! std 4thewin

... aber du mußt den anderen jetzt noch sagen, daß hier die bits von "links" gezählt werden. (Bit 0 ist das Most Significant Bit (MSB), Bit 31 ist das LSB). Nicht daß sich hier einer noch verzählt.

@fr33g: Du kannst mit bitset Deine 8bit Flagge auch lesbarer als mit einem "Buchstaben" initialisieren:

bitset<8> flag (string("01010011"));

Hier die noch mehr Info zum bitset: http://www.cplusplus.com/reference/stl/bitset/

fr33g

ok dankeschön
jetzt kapier ichs=)

bzw eine kleine frage noch:

Wann muss ich von links ab zählen mit 0 und wann von rechts??