bitweise UND / bitweise ODER

[_fux_]

hi leute,

ich versuche momentan mit bitweisen operatoren klar zu kommen. das klappt auch soweit, jedoch lt. dieser definition: http://de.wikipedia.org/wiki/Bitweiser_Operator
is dann folgendes enstanden:

#include <iostream>
using namespace std;

int main(){

	int flag[4]={1,4,5,8}; 
	int setFlag;
	int checkFlag;

	setFlag = flag[0] | flag[3]; // gesetzte flags sind 1 und 8
	
	for(int i=1;i<10;i++){
	checkFlag = setFlag & i; // prueft ob flag setzt (i muss checkFlag ergeben)
	if(i == checkFlag) cout << "Flag " << i << " gesetzt.\n";
	}

return 0;
}

nun, das problem ist, das er auch flags erkennt eigntlich gar nicht die nicht gesetzt sind - bei einigen funktioniert es korrekt.
meine frage wäre nun, wie ich denn eine bessere flagprüfungen machen kann, falles es sowas überhaupt gibt ;D
(wichtig wäre mir auch, das mit den | und & zu behalten, ansonsten wüsste ich auch andere möglichkeiten) ^^

achso, mir ist auch bewusst warum der die falschen flags erkennt, aber es muss doch eine möglichkeit geben?

LÖSUNG
ich sitz ja nich faul rum und warte bis jemand was sagt:
so finde ich immer die korrekten flags: (ich überspringe in der for-schleifen auch offensichtlich falsche flags):

#include <iostream>
using namespace std;

int main(){

	int flag[10]={2,4,8,16,32,64,128,256,512,1024}; 
	int setFlag;
	int checkFlag;

	setFlag = flag[2] | flag[7];
	
	for(int i=1;i<=1024;i=i*2){
	checkFlag = setFlag & i; // prueft ob flag setzt (i muss checkFlag ergeben)
	if(i == checkFlag) cout << "Flag " << i << " gesetzt.\n";
	}

return 0;
}

 

[metax.]

Du solltest nicht alle Zahlen von 1 - 10 durchprobieren, sondern nur die Zweierpotenzen.
Zu deiner Überprüfung:
setFlag = 1 | 8 // = 9 , da 0001 | 1000 = 1001

Überprüfung:
9 & 1 = 1 // Flag gesetzt
9 & 8 = 8 // Flag gesetzt
9 & 9 = 9 // Flag gesetzt

Wenn du dagegen auf i == setFlag prüfst (statt checkFlag), hast du dieses Problem auch nicht mehr.

Aber ich denke, du hast da noch einen Fehler in deiner Denkweise. Flags werden überlicherweise an einzelnen Bitstellen ausgewertet und dazu dient verUNDung und verODERung mit den entsprechenden Zweierpotenzen:

Flag #1 Setzen:
flagset = flagset | 2^0

Flag #3 Löschen
flagset = flagset & (not 2^2)

Flag #5 Prüfen
boolean test = (flagset & 2^4 == 2^4)

mfg, metax.

 

[_fux_]

hi danke für deine antwort
habe glaube ich gleichzeitig genau das gleiche gefunden, nur etwas anders programmiert

zum flag loeschen:

setFlag &= ~flag[0];

das klappt dann bei mir 1a

also hier nochmal der code mit 'korrekten' kommentaren:

#include <iostream>
using namespace std;

int main(){

	int flag[10]={2,4,8,16,32,64,128,256,512,1024}; 
	int setFlag;
	int checkFlag;

	setFlag = flag[0] | flag[1] | flag[8]; // setze flag mit ODER verküpfung
	
	for(int i=1;i<=1024;i=i*2){
	checkFlag = setFlag & i; // prueft ob flag gesetzt mit UND verküpfung (i muss checkFlag ergeben)
	if(i == checkFlag) cout << "Flag " << i << " gesetzt.\n";
	}
	
	cout << "\nein flag geloescht\n\n";
	setFlag &=   ~flag[0]; // ist das gleich wie: setFlag = ~flag[0] & setFlag;

	for(int i=1;i<=1024;i=i*2){
	checkFlag = setFlag & i; //  prueft ob flag gesetzt mit UND verküpfung 
	if(i == checkFlag) cout << "Flag " << i << " gesetzt.\n";
	}
	
cout << endl;
return 0;
}

 

[Lesco]

Du könntest auch direkt (setFlag & i) ohne ==i überprüfen, da alle Zahlenwerte !=0 in C/C++ als wahr gelten. Außerdem fehlt bei deinem flag-Array die 1.

 

[ArnoNühm]

hier noch was aus der konserve:

inline void setbit(unsigned char bit, unsigned long& bitblock)
{
	bitblock |= (1 << bit);
}

inline void clearbit(unsigned char bit, unsigned long& bitblock)
{
	bitblock &= ~(1 << bit);
}

inline void switchbit(unsigned char bit, unsigned long& bitblock)
{
	bitblock ^= (1 << bit);
}

inline bool getbit(unsigned char bit, unsigned long bitblock)
{
	if((bitblock & (1 << bit)) != 0) return true;
	return false;
}

Vielleicht kannst du damit was anfangen.

 

[_fux_]

sieht nett aus
wenn ich wieder bisschen c++ übe schau ich mir das ganze nochmal genauer an. nice nice