Bitsets vergleichen



  • Hallo,
    ich habe in meinem Programm Objekte, die eine Signatur von std::bitset < 32 > enthalten. Diese repräsentiert ob das Objekt bestimmte Komponenten enthält oder nicht.
    Jetzt möchte ich Folgendes erreichen: Eine Klasse System sucht sich nun aus jedem Objekt diese Signatur heraus und vergleicht sie mit der im System zur Verarbeitung Vorausgesetzten. ( Also ebenfalls std::bitset < 32 > ). Dabei soll die Regel gelten, dass es keine Rolle spielt ob die beiden zu 100 Prozent übereinstimmen. Wichtig ist nur, dass die vorausgesetzte Signatur an jeder Stelle, an der sie 1 bzw. wahr entspricht, mit derjenigen des Objektes übereinstimmt. ( z.B. Vorausgesetzt : 10001, Objekt : 10101, Ergebnis : Zur Verarbeitung freigegeben ! )

    Ich hoffe ich konnte das Problem vernünftig darstellen 😃
    Nun hier der Code, den ich schnell zusammengebastelt habe :

    #include <algorithm>
    #include <bitset>
    #include <iostream>
    #include <string>
    
    using namespace std;
    
    bool compare(bitset<32>& lhs, bitset<32>& rhs)
    {
    	auto str1 = lhs.to_string();
    	auto str2 = rhs.to_string();
    
    	for (auto it = str1.find_first_of("1"); it != str1.npos; it = str1.find_first_of("1", it + 1))
    	{
    		if (str1[it] != str2[it])
    			return false;
    	}
    
    	return true;
    }
    
    int main()
    {
    	bitset < 32 > b1{ "000000010000000000000010000000" };
    	bitset < 32 > b2{ "000000010000000010000010000000" };
    
    	bool result{ compare(b1, b2) }; // result soll hier true sein ! 
    
    	cout << boolalpha << result;
    
    	getchar();
    
    	return EXIT_SUCCESS;
    }
    

    Gibt es eine bessere Methode dies zu erreichen ?


  • Mod

    Ver-AND-en und dann vergleichen? Also kurz

    if (signatur == signatur & anderes_bitset) ...
    

    Normalerweise ist es keine gute Idee, auf Zeichenkettenverarbeitung zurück zu greifen, wenn man Mathematik machen möchte. Das ist ein sicheres Zeichen, dass man etwas zu umständlich macht. Das gilt nicht nur hier sondern ist etwas, was du dir allgemein merken solltest.



  • Eher:

    if (signatur == (signatur & anderes_bitset))
    

  • Mod

    Caligulaminus schrieb:

    Eher:

    if (signatur == (signatur & anderes_bitset))
    

    Stimmt. Wer kommt denn auch auf die Idee, eine Operation, die sich wie ein + anfühlt, auf eine niedrigere Stufe zu stellen als einen Vergleich 😃



  • Danke für die schnelle Antwort 👍
    Aber bei der Geschwindigkeit merkt man gar keinen Unterschied 🤡
    ( 1.000.000 Durchläufe, 109.381 Mikrosekunden vs. 41.665.825 Mikrosekunden 😃 )


  • Mod

    SeppJ schrieb:

    Stimmt. Wer kommt denn auch auf die Idee, eine Operation, die sich wie ein + anfühlt, auf eine niedrigere Stufe zu stellen als einen Vergleich 😃

    Wie immer hat so ein Quatsch nur historische Gründe. Die bitweisen und logischen Operatoren waren ursprünglich beide durch & und | vertreten. Nachdem die Unterscheidung via && und || eingebracht worden war, war aber bereits zu viel Code im Umlauf, der durch eine Änderung der Operatorpräzedenz plötzlich eine ganz andere Semantik gehabt hätte:

    if (a == b & c == d)
    

    funktioniert (und wird Heute selbstverständlich als Nonsens abgestempelt).

    Siehe http://www.lysator.liu.se/c/dmr-on-or.html



  • SeppJ schrieb:

    Stimmt. Wer kommt denn auch auf die Idee, eine Operation, die sich wie ein + anfühlt, auf eine niedrigere Stufe zu stellen als einen Vergleich 😃

    Wenn ich mir die neutralen Elemente in der Booleschen Algebra so ansehe, fühlt sich das für mich eher wie ein * an.
    a && true == a und a || false == a
    vs.
    a * 1 == a und a + 0 == a
    Nichts für ungut, ist nur ein Detail am Rande 😉
    Glaube die Elektrotechniker schreiben das sogar so. Hat mir immer gut gefallen die Notation... von dem ganzen v- und Hütchen-Geraffel haben mir seinerzeit immer die Augen geflimmert.

    Finnegan


Anmelden zum Antworten