class Klasse{int a; int b;};
Klasse Objekt;

if(Objekt)
{
//...
}

Nur habe ich keine Ahnung, welcher das sein könnte, ja noch nicht mal, ob es überhaupt einen solchen gibt...

Mit operator!() hat ja zumindest mal das Gegenteil geklappt, also kanns ja nicht unmöglich sein....

Wie wäre es mit einem benutzerdefinierten Konvertierungsoperator für den Typ bool?

Lieber nicht... damit wird ein Objekt der Klasse mit so ziemlich allem und extrem unkontrolliert vergleichbar.
Die IOstreams machen das (mit gutem Grund) über operator void*. Ich persönlich halte Abfragen wie if( objekt) nur für Schreibfaulheit, die man mit einer gut benannten Methode viel besser ersetzen könnte.

~Edit: deutsche Sprache schwere Sprache =)~

operator void* ... ich stehe ja eigentlich nicht so auf void-Zeiger... da lässt sich doch noch viel mehr Wahnsinn zuweisen?

Unkontrolliert vergleichbar? Bei bool könnte doch da nicht viel passieren? Gibt ja schließlich nur zwei Zustände, wenn man jetzt den Operator mit einer anderen bool-Variable vergleicht, ist es ja nicht so, als ob eine Übereinstimmung besteht, obwohl sich die Inhalte widersprechen...

Das ist nicht das Problem. Das Problem ist, dass ziemlich viele Dinge implizit in bool konvertierbar sind. Damit bastelt dir der Compiler aus den wildesten Konstrukten, die sonst womöglich eine Fehlermeldung erzeugen würden, irgendetwas hin, das diesen Operator benutzt.

operator void* ... ich stehe ja eigentlich nicht so auf void-Zeiger... da lässt sich doch noch viel mehr Wahnsinn zuweisen?

Mit einem void* kannst du (implizit) nicht viel mehr machen als ihn auf != 0 zu prüfen. Zuweisen kannst du da sowieso nichts. 7H3 N4C3R hat mit seinem Einwand recht.

Edit: Hm da war MFK schneller

TToolTnc::WZ_Var::operator void*()
{
  if(this->VarName.IsEmpty() && this->Value.IsEmpty())
    return NULL;
  else 
    return this;
}

Habs jetzt direkt aus dem Code genommen und kein Beispiel gebastelt, weil man wohl erkennen kann, worums geht.

Nun, es erscheint mir so ein wenig komisch, schließlich liegt das Objekt ja nicht tatsächlich auf NULL. Aber wenn ich stattdessen versuche, einem Objekt NULL zuzuweisen, damit der Operator korrekte Werte zurückgibt, bekomme ich nen Konvertierungsfehler. Jetzt könnte ich da auch einen Zuweisungsoperator hinwurschteln, aber dann könnte man schon wieder jeden Müll zuweisen.

Wo liegt denn diesmal mein Denkfehler?

Aber wenn ich stattdessen versuche, einem Objekt NULL zuzuweisen, damit der Operator korrekte Werte zurückgibt,

Wozu "korrekte Werte"? void* ist hier nur eine Krücke, damit du eine möglichst kontrollierte Umwandlung nach bool hinbekommst. Der Zeiger ist nur für Vergleiche mit 0 vorgesehen, nicht, um damit auf das Objekt zuzugreifen. Der Zeiger muss daher auch nichts mit der Adresse des Objekts zu tun haben. Du musst nicht this zurückgeben, jeder andere von 0 verschiedene Zeiger tut's auch.

operator void* ... ich stehe ja eigentlich nicht so auf void-Zeiger... da lässt sich doch noch viel mehr Wahnsinn zuweisen?

Nunja, eigentlich kannst du nur andere Zeiger damit vergleichen. Du kannst es aber auch vollkommen idiotensicher machen. Dazu nimmst du eine simple Klasse, zB:

class safe_bool
{
public:
	typedef void (safe_bool::*type)();
	static type value(bool source)
	{
		return source ? &safe_bool::non_null : NULL;
	}
private:
	void non_null()
	{
	}
};

Die Verwendung sieht dann wie folgt aus:

operator safe_bool::type() const
{
	return safe_bool::value(!this->VarName.IsEmpty() || !this->Value.IsEmpty());
}

void non_null()
{
}

diese funktion wird leider generiert, weil da jemand von die adresse gezogen hat. ich würde lieber reinterpret_cast nehmen als sowas.
warum nicht this? das liegt doch eh im register cx und mit mov ax,cx breicht man nur einen takt, um this als returnwert zu haben.

außerdem würde ich nen zeiger auf nen typen zurückgeben. auf struct NoType{}; vielleicht. der ist dann eh nur mit 0 vergleichbar, aber das macht nix.

#include <iostream>
struct foo
{
	void bar() const {}
	typedef void (foo::*safe_bool)() const;
	struct bar2 {};
	static const bar2 b;
	operator bool() const { return m < RAND_MAX / 2; }
//	operator const void*() const { return m < RAND_MAX / 2 ? this : 0; }
//	operator const bar2*() const { return m < RAND_MAX / 2 ? &b : 0; }
//	operator safe_bool() const { return m < RAND_MAX / 2 ? &foo::bar : 0; }
	int m;
};
const foo::bar2 foo::b;
unsigned rdtsc() { __asm rdtsc }
int main()
{
	using namespace std;
	foo a;
	srand( rdtsc() );
	a.m = rand();
	if ( a )
		cout << "true";
	else
		cout << "false";
}

das ganze compiliert mit vc++ 7.1 mit allen optimierungenergibt:

21: 	a.m = rand();
0040101B E8 70 29 00 00   call        rand (403990h) 
    22: 	if ( a )
00401020 3D FF 3F 00 00   cmp         eax,3FFFh 
00401025 7D 13            jge         main+2Ah (40103Ah) 
    23: 		cout << "true";
00401027 68 28 C1 40 00   push        offset string "true" (40C128h)

mit operator const void*:

21: 	a.m = rand();
0040101C E8 7F 29 00 00   call        rand (4039A0h) 
    22: 	if ( a )
00401021 33 C9            xor         ecx,ecx 
00401023 3D FF 3F 00 00   cmp         eax,3FFFh 
00401028 0F 9D C1         setge       cl   
0040102B 8D 14 24         lea         edx,[esp] 
0040102E 83 E9 01         sub         ecx,1 
00401031 85 CA            test        edx,ecx 
00401033 74 14            je          main+39h (401049h) 
    23: 		cout << "true";
00401035 68 28 C1 40 00   push        offset string "true" (40C128h)

mit operator const bar2*

21: 	a.m = rand();
0040101B E8 80 29 00 00   call        rand (4039A0h) 
    22: 	if ( a )
00401020 33 C9            xor         ecx,ecx 
00401022 3D FF 3F 00 00   cmp         eax,3FFFh 
00401027 0F 9D C1         setge       cl   
0040102A 83 E9 01         sub         ecx,1 
0040102D F7 C1 1C C1 40 00 test        ecx,offset foo::b (40C11Ch) 
00401033 74 13            je          main+38h (401048h) 
    23: 		cout << "true";
00401035 68 28 C1 40 00   push        offset string "true" (40C128h)

und mit operator safe_bool:

21: 	a.m = rand();
0040102B E8 80 29 00 00   call        rand (4039B0h) 
    22: 	if ( a )
00401030 33 C9            xor         ecx,ecx 
00401032 3D FF 3F 00 00   cmp         eax,3FFFh 
00401037 0F 9D C1         setge       cl   
0040103A 83 E9 01         sub         ecx,1 
0040103D F7 C1 00 10 40 00 test        ecx,offset foo::bar (401000h) 
00401043 74 13            je          main+38h (401058h) 
    23: 		cout << "true";
00401045 68 28 C1 40 00   push        offset string "true" (40C128h)

nun sieht das mit einem anderen compiler sicher anders aus.
bleibt festzuhalten: nur operator bool() wird optimal übersetzt - das problem ist hier aber, dass der compiler sich nicht bewusst ist, dass benannte objekte niemals die adresse 0 haben können. das lässt sich heilen - allerdings nicht gänzlich standardkonform (da pointer auch trapvalues haben können):
mit

operator const void*() const { return m < RAND_MAX / 2 ? (const void*)1 : 0; }

erhalte ich:

31: 	a.m = rand();
0040101B E8 70 29 00 00   call        rand (403990h) 
    32: 	if ( a )
00401020 3D FF 3F 00 00   cmp         eax,3FFFh 
00401025 7D 13            jge         main+2Ah (40103Ah) 
    33: 		cout << "true";
00401027 68 28 C1 40 00   push        offset string "true" (40C128h)

wunderbar. das ganze geht auch für memberfuntionpointer:

operator safe_bool() const
	{
		union
		{
			unsigned x;
			safe_bool result;
		} result = { m < RAND_MAX / 2 };
		return result.result;
	}

31: 	a.m = rand();
0040101B E8 70 29 00 00   call        rand (403990h) 
    32: 	if ( a )
00401020 3D FF 3F 00 00   cmp         eax,3FFFh 
00401025 7D 13            jge         main+2Ah (40103Ah) 
    33: 		cout << "true";
00401027 68 28 C1 40 00   push        offset string "true" (40C128h)

sehr schön. da jetzt auch bezug auf bar::foo() mehr genommen wird spart man diese 16 byte (1 byte function, 15 byte für ausrichtung des einsprungpunktes, so sinnlos das hier auch ist) auch noch ein.

fazit: mit ein paar tricks kann jede form optimalen code liefern. memberfunctionspointer sind dann aber am sichersten, denn auch mit bar* kann man noch viele unsinnige sachen wie pointerarithmetik betreiben (es sei denn, bar ist ein unvollständiger typ, aber dann muss man auch wieder einen hack wie oben benutzen, um ein bar* zurückliefern zu können). ausserdem ist sowohl bar* als auch void* mit jedem anderen void* pointer vergleichbar.

Nunja, eigentlich kannst du nur andere Zeiger damit vergleichen. Du kannst es aber auch vollkommen idiotensicher machen. Dazu nimmst du eine simple Klasse, zB:

Also nehmen wir mal eine Klasse MeinStream, deren Zustand mit operator safe_bool überprüfbar ist, und eine Klasse Farbe, deren safe_bool "true" ergibt, wenn die Farbe nicht unsichtbar ist, und wir bekommen

void doBockmist(MeinStream& a, Farbe& b)
{
    if (a == b) ...;
}

Boost bietet doch afaik eine safe_bool-Bibliothek an - ich würde mich einfach mal darauf verlassen, dass das da einigermaßen vernünftig gelöst ist.

safe_bool überprüfbar ist, und eine Klasse Farbe, deren safe_bool "true" ergibt, wenn die Farbe nicht unsichtbar ist, und wir bekommen

void doBockmist(MeinStream& a, Farbe& b)
{
    if (a == b) ...;
}

das ist auch sinnvoller code.
der sagt "wenn a den gleichen gültigkeitswert hat wie b". null probleme und sinnvoll.
es gibt darum, daß man nicht bei
cout<<a; vom rechner "true" erzählt kriegt, sondern das richtige "ätsch, ich kann gar keinen MeinStream ausgeben".

So kann mans natürlich auch interpretieren. Ich finde das eine sehr verwirrende Benutzung des operator==, andererseits würde ich auch nie auf die Idee kommen, irgendeine spezielle Eigenschaft meines Objekts per if (obj) abzufragen. Ich bin dann eher der "bool isXyz() const"-Typ, glaube ich.

naja, jeder wird wohl irgendwann sowas gemacht haben:

Object* p=foo();
if(p){
    ....
}

wieso dann nicht auch so?

SmartPointer<Object> p=foo();
if(p){
    ....
}

volkard schrieb:

sag mir ma, wie groß sizeof type ist

Wozu? Stört dich der Member-Funktionszeiger? Den kann man natürlich noch eliminieren.

class safe_bool
{
private:
	struct closed
	{
	};
public:
	typedef void (*type)(closed);
	static type value(bool source)
	{
		return source ? &safe_bool::non_null : NULL;
	}
private:
	static void non_null(closed)
	{
	}
};

volkard schrieb:

warum nicht this?

Weil ich in einer Non-Memberfunktion nunmal kein this habe. Ich bin aber schon gespannt auf ein Beispiel von dir.

volkard schrieb:

sag mir ma, wie groß sizeof type ist

Wozu? Stört dich der Member-Funktionszeiger?

8 oder 12 bytes. nicht 4, und damit schmerzhaft.

Den kann man natürlich noch eliminieren.

class safe_bool
{
private:
	struct closed
	{
	};
public:
	typedef void (*type)(closed);
	static type value(bool source)
	{
		return source ? &safe_bool::non_null : NULL;
	}
private:
	static void non_null(closed)
	{
	}
};

der vorteil deines member-zeugs war wohl, daß man die sehr schwer aus versehen casten kann.
einen möglichen fehler sehe ich sogar. man hantiert mit zeigern und placement-new. und das will nen void*. und man steckt nen safe_bool rein.
wird der aktuelle normale funktionszeiger nicht von allein in nen void* konvertiert?

volkard schrieb:

warum nicht this?

Weil ich in einer Non-Memberfunktion nunmal kein this habe. Ich bin aber schon gespannt auf ein Beispiel von dir.[/quote]
satic zu nehmen ist neu.
mir scheint, reinterpret_cast muß her.

der vorteil deines member-zeugs war wohl, daß man die sehr schwer aus versehen casten kann.

Yep.

volkard schrieb:

einen möglichen fehler sehe ich sogar. man hantiert mit zeigern und placement-new. und das will nen void*. und man steckt nen safe_bool rein.
wird der aktuelle normale funktionszeiger nicht von allein in nen void* konvertiert?

An das implizite Casten nach void* hab ich jetzt beim zweiten Beispiel gar nicht mal gedacht. Aber ein weiterer Grund, weshalb ich wohl beim Member-Funktionszeiger bleiben werden.

volkard schrieb:

volkard schrieb:

warum nicht this?

Weil ich in einer Non-Memberfunktion nunmal kein this habe. Ich bin aber schon gespannt auf ein Beispiel von dir.

satic zu nehmen ist neu.
mir scheint, reinterpret_cast muß her.

Ich bin immer noch auf Code von dir gespannt. Ich habe es nicht geschafft, gültigen Code mit this zu schreiben, da dies auch mein erster Ansatz war. Allerdings habe ich nicht allzu viel Zeit darin investiert, um sagen zu können, alle Fälle abgecheckt zu haben.