in if() auf bits testen?

sn0b

muß es nicht

[cpp]if (auto && auspuf)[/cpp]

heißen?

Walli

Ne, ich glaub auto ist ein denkbar ungünstiger Variablenname .

truebool

nein muss es nicht denn soweit ich es vestehe meint er
den bitweisen AND-operator
des weiteren möchte ich anmerken das variablen keine c++-schlüsselwörter sein sollten.
wie "long auto;"

edit .zu langsam -.-

geht leider alles nicht,

also bei der Zuweisung und beim Prüfen meckert der Kompiler:

testvar = testbita | testbitb;

= Syntaxerror befor | token

if (testvar & testbita && testvar & testbitb)

= auch syntaxerror

wie geht das den, das ich Atribute einer Variable zu ordne die ich dann testen kann mit if?

PS: ich habe natürlich nicht auto verwendet, das war nur hier zum besseren verständnis.

Dann kicke mal deinen Compiler und suche dir einen, der Anständige Fehlermeldungen ausgibt, und nicht nur ein schlichtes "Syntax Error".

Gerade als Anfänger ist man da ja sonst verloren.

Ich sehe in testvar = testbita | testbitb; jedenfalls keinen Fehler.

Hier mein kleines Test Programm:

#include <iostream>
#include <stdlib.h>

#define testbita 0x40;
#define testbitb 0x80;
long testvar;
int ok;

using namespace std;

int main(int argc, char *argv[])
{
  ok = 0;
  testvar = testbita | testbitb;

  if (testvar & testbita) ok++;
  if (testvar & testbitb) ok++;

  if (ok == 2) cout << "ok";

  system("PAUSE");	
  return 0;
}

Fehlermeldung von dev-cpp:

main.cpp: In function `int main(int, char**)':

main.cpp:15: error: syntax error before `|' token

main.cpp:17: error: syntax error before `;' token

main.cpp:18: error: syntax error before `;' token

Ja, das geht so natürlich nicht.

Die Defines sind ja nur "Platzhalter" die an die entsprechende Stelle im Quelltext ersetzt werden.
Da die Zeile danach aber noch nicht zuende ist, ohne ";".

Helium

Ein weiterer Grund #define für soetwas zu vermeiden: Die Semikolons (korrekter Plural bitte?) sind falsch. Überleg einfach, was passiert, wenn der Präprozessor fertig ist:

testvar = 0x40; | 0x80;;

Das ist natürlich Käse.

Ersetzt du

#define testbita 0x40;
#define testbitb 0x80;

durch

const int testbita = 0x40;
const int testbitb = 0x80;

geht's.

Horst2

#include <iostream> 
#include <stdlib.h> 

#define TESTBITA 0x40
#define TESTBITA 0x80 

long testvar; 
int ok; 

using namespace std; 

int main(int argc, char *argv[]) 
{ 
  ok = 0; 
  testvar = testbita | testbitb; 

  if (testvar & TESTBITA) ok++; 
  if (testvar & TESTBITA) ok++; 

  if (ok == 2) cout << "ok" << endl; 

  system("PAUSE");    
  return 0; 
}

so funktioniert es gut bis sehr gut

Helium

So und jetzt hättte ich gerne deine Erklärung dafür, warum du lieber Makros statt Konstanten verwendest?

Also wie folgt funktioniert es perfekt:

#include <iostream>
#include <stdlib.h>

const int testbita = 0x40;
const int testbitb = 0x80;
long testvar;
int ok;

using namespace std;

int main(int argc, char *argv[])
{
  ok = 0;
  testvar = testbita | testbitb;

  if (testvar & testbita && testvar & testbitb) ok++;

  if (ok == 1) cout << "ok" <<endl;

  system("PAUSE");	
  return 0;
}

aber ich verstehe nicht warum es mit defines nicht geht, denn...
bei Windows geht es auch, da sind z.B. alle WIndow-Styles (WS_xxxx) als defines
und werden auch mittels | angegeben (..., WS_CAPTION | WS_CHILD,....)

warum gehts da und sonst nicht?

Walli

Es geht schon, aber ob es sinnvoller als einfache Konstanten ist sei mal dahin gestellt...

camper

es gibt einen haufen gründe, consts statt macros zu nehmen, eine auswahl:

1. macros überladen nicht und der präprozessor kennt auch keine namespaces
2. macros sind reine textsymbole, wenn du einen intelligenten compiler hast, kann er dir bei fehlern evtl. noch sinnvolle meldungen bringen, aber spätestens beim debuggen hast du ein problem. der debugger kennt diese macros nähmlich nicht, was das debuggen sehr erschweren kann.
3. macros sind, da es sich um textsymbole handelt, untypisiert. der typ den das macro hat, hängt vom kontext ab, was leicht zu subtilen oder auch mal schweren fehlern führt.
4. macros müssen dort, wo sie verwendet werden auch definiert sein. ein const könnte dagegen problemlos auch mal extern sein, wenn der konkrete wert des consts beim compilieren nicht gebraucht wird.

hehejo

Warum sind defines böse?

Weil der Compiler sie nie zu Gesicht bekommt!
Defines werden durch den Präprozessor ersetzt.

Beispiel

// diesen code siehst du:
#define WERT_A 4;
#define WERT_B 5;

int main()
{
  int i = WERT_A + WERT_B;
  return 0;
}

des macht der Präprozessor draus
dies sieh dein Compiler
[cpp]
int main()
{
int i = 4**;** + 5**;**;
return 0;
}
// Ist doch klar, dass das nicht geht!
[/cpp]

Was siehst aber du bei einem Syntaxerror in
"Zeile 3 bei Token +"

int i = WERT_A + WERT_B;

Und du bist am verzweifeln!

[cpp]
// machst du das jetzt aber als
const int WERT_A = 4;
const int WERT_B = 5:
// Dann ersetzt der Präprozessor nichts und der Compiler sieht WERT_A und WERT_B
// und kann dich auf Fehler richtig aufmerksam machen.
[/cpp]
Klar funktioniert das mit #defines. Ist aber nicht schön und hier ist auch das C++-Forum (Im C-Forum ist das wieder ok)

Alles klar?

alles klar?

nicht ganz, ich verstehe nicht warum der Präprozessor nach auswechseln eines Wertes, automatisch ein ";" hintersetzt, so kann man defines ja praktisch gar nicht verwenden.

Braunstein

Das Semikolon hast du doch da hingesetzt. Der Präprozessor übernimmt das bloß.

Braunstein schrieb:

Das Semikolon hast du doch da hingesetzt. Der Präprozessor übernimmt das bloß.

Danke, jetzt habe ich es verstanden und ohne ; geht das natürlich, ist halt gewohnheit das ; zu setzten.

Doch wo liegt nun der Unterschied zwischen const und #define?
bei #define wechselt der Präprozessor den Wert aus, so das er fest im code steht. Aber const trägt auch einen festen wert, so das es eigentlich egal ist ob der compiler die Variable sieht oder einen festen wert, da bei const der wert nicht geändert werden kann.

Also. was macht da jetzt der Unterschied?

Walli

hehejo schrieb:

Klar funktioniert das mit #defines. Ist aber nicht schön und hier ist auch das C++-Forum (Im C-Forum ist das wieder ok)

Ne, ist es nicht! Auch in C ist es nicht sinnvoll Makros zu benutzen wenn man Konstanten definieren will.

Walli

Anfänger_frage schrieb:

Also. was macht da jetzt der Unterschied?

const hat keine Nachteile wenn man damit Konstanten definiert.