🚀 go-pugleaf

speiser@steinway.u-strasbg.fr (Hans Martin SPEISER ) wrote:
>Hallo Sie da,
>
>Mein Problem ist jetzt nur das ich bei einer Funktion, wie zum Beispiel  
>"ist_alles_ok", die boolean als Ergebnistyp hat keine "if" Anfrage  
>hinbekomme. Also zum Beispiel sowas:
>	if (ist_alles_ok) ...
>Es kommt dann immer die Fehlermeldung "illegal structure operation".
>Definiere ich die Funktion "ist_alles_ok" mit dem Ergebnistyp "int", dann  
>verschwindet das Problem.
>
>Also, was mache ich falsch?

Soweit ich weiss, gehoert hinter einen Funktionsaufruf ein "()", also
Mit dem, was du machst, fragst Du den Zeiger auf die Funktion ab.

if (ist_alles_ok())
{
    blah();
}

evtl. hast Du das uebersehen, oder ich habe deine Frage falsch verstanden.

--
Markus Becker
Zentrum fuer Sensorsysteme (ZESS)

http://www.zess.uni-siegen.de/
http://www.zess.uni-siegen.de/private/becker/
http://www.zess.uni-siegen.de/private/becker/win95

 speiser@steinway.u-strasbg.fr (Hans Martin SPEISER ) wrote:
>Um von den gegebenen Typen in BC 4.5 zu abstrahieren, habe ich eine Klasse  
>"boolean" entworfen. Sie hat das Attribut "value" das die Werte 0 und 1  
>aus der "enum (FALSE, TRUE)" annimmt. Alles schoen und gut.
>
>Mein Problem ist jetzt nur das ich bei einer Funktion, wie zum Beispiel  
>"ist_alles_ok", die boolean als Ergebnistyp hat keine "if" Anfrage  
>hinbekomme. Also zum Beispiel sowas:
>	if (ist_alles_ok) ...
>Es kommt dann immer die Fehlermeldung "illegal structure operation".

Das ist ja auch kein Wunder, da if einen Ausdruck von Typ int oder nun
besser bool haben moechte. Du gibst ihm aber ein Objekt vom Typ
boolean, womit if nix anfangen kann.
Am besten definierst du einen operator int() oder besser operator
bool(), wenn dein Compiler den bool-Typ schon hat. Also z.B.:

class boolean
{
...
public:
...

  operator bool() {return Wahrheitswert;}
};

-- 
Frank Thilo   -  gl600@appl2.hrz.uni-siegen.de
IRC: Chestal  -  <A HREF="http://vespa.unix-ag.uni-siegen.de/~thilo">Click</A>

Am 31. Okt. 1995 schrieb Hans Martin SPEISER
(speiser@steinway.u-strasbg.fr):

> Hallo Sie da,

> ich habe da ein Problem, dass ziemlich banal klingt aber ich bekomme es  
> einfach nicht auf die Reihe. Folgendes ist passiert:

> Um von den gegebenen Typen in BC 4.5 zu abstrahieren, habe ich eine Klasse  
> "boolean" entworfen. Sie hat das Attribut "value" das die Werte 0 und 1  
> aus der "enum (FALSE, TRUE)" annimmt. Alles schoen und gut.

> Mein Problem ist jetzt nur das ich bei einer Funktion, wie zum Beispiel  
> "ist_alles_ok", die boolean als Ergebnistyp hat keine "if" Anfrage  
> hinbekomme. Also zum Beispiel sowas:
> 	if (ist_alles_ok) ...
> Es kommt dann immer die Fehlermeldung "illegal structure operation".
> Definiere ich die Funktion "ist_alles_ok" mit dem Ergebnistyp "int", dann  
> verschwindet das Problem.

So ganz verstehe ich nicht, was Du da gemacht hast. Ein Beispiel wäre da
günstig gewesen. Darum muß ich einige Vermutungen anstellen, was schief
gelaufen ist. War es etwa so?

	class boolean { ... };
	boolean ist_alles_ok();

	if ( ist_alles_ok() ) { ... }

Das kann nicht funktionieren, denn "if" erwartet einen Ausdruck vom Typ
"int" oder einen Zeiger. Ein Konvertierungsoperator, den Konvertierungen
von "boolean" nach "int" ermöglicht, würde hier helfen:

	class boolean {
	   ...
	   operator int() { return value; }
	};

Ich verstehe sowieso nicht ganz, warum Du "boolean" als Klasse
definierst. Näherliegend wäre doch folgendes:

	enum boolean { false=0, true=1 };

	inline boolean operator| (boolean a, boolean b) 
	{ return boolean(int(a) | int(b)); }

	inline boolean operator& (boolean a, boolean b)
	{ return boolean(int(a) & int(b)); }

	inline boolean operator^ (boolean a, boolean b)
	{ return boolean (int(a) ^ int(b)); }

	inline boolean operator! (boolean a) { return boolean(!int(a)); }



Karl-Heinz Krause

In article <474ur7$cul@apopi.u-strasbg.fr>, speiser@steinway.u-strasbg.fr (Hans Martin SPEISER ) says:
>Ich habe da ein Problem, dass ziemlich banal klingt aber ich bekomme es  
>einfach nicht auf die Reihe. Folgendes ist passiert:
>Um von den gegebenen Typen in BC 4.5 zu abstrahieren, habe ich eine Klasse  
>"boolean" entworfen. Sie hat das Attribut "value" das die Werte 0 und 1  
>aus der "enum (FALSE, TRUE)" annimmt. Alles schoen und gut.
>Mein Problem ist jetzt nur das ich bei einer Funktion, wie zum Beispiel  
>"ist_alles_ok", die boolean als Ergebnistyp hat keine "if" Anfrage  
>hinbekomme. Also zum Beispiel sowas: if (ist_alles_ok) ...
>Es kommt dann immer die Fehlermeldung "illegal structure operation".
>Definiere ich die Funktion "ist_alles_ok" mit dem Ergebnistyp "int", dann  
>verschwindet das Problem.
>Also, was mache ich falsch?
>Danke fuer Tips... Hanni



Warum machst du's dir unnoetig schwer und definierst fuer diesen einfachen Typ
eine Klasse? Ein einfaches enum boolean {FALSE,TRUE} reicht doch schon. Die
logischen Operatoren wie ||, && und ! funktionieren auch so.

Vielleicht beschreibst du deine Gruende etwas naeher?!

Viel Spass noch,

Martin

mgieseki@carina.rz.uni-osnabrueck.de (Martin Gieseking) writes:

MG> Warum machst du's dir unnoetig schwer und definierst fuer diesen
MG> einfachen Typ eine Klasse? Ein einfaches enum boolean {FALSE,TRUE}
MG> reicht doch schon.

Falsch.  Es muß heißen:

  #ifdef OBSOLETE_COMPILER
  enum bool { false, true };
  #endif

weil bool inzwischen in der Sprache drin ist.

speiser@steinway.u-strasbg.fr (Hans Martin SPEISER ) wrote:

>Hallo Sie da,

>ich habe da ein Problem, dass ziemlich banal klingt aber ich bekomme es  
>einfach nicht auf die Reihe. Folgendes ist passiert:

>Um von den gegebenen Typen in BC 4.5 zu abstrahieren, habe ich eine Klasse  
>"boolean" entworfen. Sie hat das Attribut "value" das die Werte 0 und 1  
>aus der "enum (FALSE, TRUE)" annimmt. Alles schoen und gut.

>Mein Problem ist jetzt nur das ich bei einer Funktion, wie zum Beispiel  
>"ist_alles_ok", die boolean als Ergebnistyp hat keine "if" Anfrage  
>hinbekomme. Also zum Beispiel sowas:
>	if (ist_alles_ok) ...
>Es kommt dann immer die Fehlermeldung "illegal structure operation".

enum BOOLVAL
{
	FALSE = 0,
	TRUE
};

class BOOLEAN
{
public:
	BOOLEAN(BOOLVAL v):
		value(v)	{}
	//	Du must eine Typkonvertierung schreiben:
	operator int()
		{return value;}	
private:
	BOOLVAL	value;
};

Joachim
"I read the news today oh boy"             - The Beatles - A Day In The Life

Karl-Heinz Krause (Krause@btx.dtag.de) wrote:

[ ... ]

>  	if ( ist_alles_ok() ) { ... }

>  Das kann nicht funktionieren, denn "if" erwartet einen Ausdruck vom Typ
>  "int" oder einen Zeiger. 

Ohne pingelig wirken zu wollen: if erwartet einen Wert eines beliebigen
ganzzahligen Typs (also auch char, long etc.)!

Gruss
	Bernd

--
+----------------------------------+
|          Bernd Eggink            |
|    Rechenzentrum Uni Hamburg     |
| admin@rzaix13.rrz.uni-hamburg.de |
+----------------------------------+

In <477ms4$gim@deimos.rz.uni-osnabrueck.de> mgieseki@carina.rz.uni-osnabrueck.de (Martin Gieseking) writes:
>Warum machst du's dir unnoetig schwer und definierst fuer diesen einfachen Typ
>eine Klasse? Ein einfaches enum boolean {FALSE,TRUE} reicht doch schon. Die
>logischen Operatoren wie ||, && und ! funktionieren auch so.

Aber nur, weil der Compiler enums als ints ab 0 ablegt. Dazu ist er aber
nicht verpflichtet, oder?

In C kenn ich die Variante:

#define FALSE 0
#define TRUE  !FALSE

ist natuerlich fuer C++ eigentlich nicht zu empfehlen, weil kein
Type-Checking gemacht wird.

Im neuen Standard sollen doch booleans sowieso mit aufgenommen werden,
oder?

Gruesse, Benni
-- 
benni@informatik.uni-frankfurt.de|http://www.uni-frankfurt.de/gnomic/hello.html
    "Deshalb, Leute, die glauben, dass Computer werden nicht koennen, wie
      Menschen zu denken, auch glaubt nicht in Maschine-Uebersetzung."

In article <47cq9j$cgb@zeus.rbi.informatik.uni-frankfurt.de>, benni@dares.rbi.informatik.uni-frankfurt.de (Benjamin Baermann) writes:

|> In <477ms4$gim@deimos.rz.uni-osnabrueck.de> mgieseki@carina.rz.uni-osnabrueck.de (Martin Gieseking) writes:
|>> Warum machst du's dir unnoetig schwer und definierst fuer diesen einfachen Typ
|>> eine Klasse? Ein einfaches enum boolean {FALSE,TRUE} reicht doch schon. Die
|>> logischen Operatoren wie ||, && und ! funktionieren auch so.

|> Aber nur, weil der Compiler enums als ints ab 0 ablegt. Dazu ist er aber
|> nicht verpflichtet, oder?

Doch.  Enums fangen immer mit 0 an, falls nichts anderes angegeben
wurde.

|> In C kenn ich die Variante:

|> #define FALSE 0
|> #define TRUE  !FALSE

|> ist natuerlich fuer C++ eigentlich nicht zu empfehlen, weil kein
|> Type-Checking gemacht wird.

|> Im neuen Standard sollen doch booleans sowieso mit aufgenommen werden,
|> oder?

Es gibt die neuen Schluesselwoerter bool, true und false.  Das ist in
GCC schon implementiert.
-- 
Andreas Schwab                                      "And now for something
schwab@issan.informatik.uni-dortmund.de              completely different"

Benjamin Baermann writes:
> Im neuen Standard sollen doch booleans sowieso mit aufgenommen werden,
> oder?

Ja, und das gibt es beim gcc schon seit 2.6.x.


ralf
--
PGP: 1024/0xA713ECE9 2047/0xC8E605F5