Boolean-Wert ändern

[Martin K]

Hab mal eine allgemeine Frage:

Gibt es in Delphi eine vorgefertige Prozedur, die einen Boolean-Wert ändert (aus True ein False macht und aus False ein True macht), also so was wie Inc() bei Zahlen???

Hab's mal probiert mit Inc und einem Boolean-Wert:
Der Compiler meckert zwar nicht, aber der Wert meiner Variablen bleibt gleich.

[fkerber]

Hi!

Du könntest es mit not versuchen:

Delphi-Quellcode:

variable := not variable;

Ciao Frederic

[Martin K]

Ja, das geht.
Danke fkerber!

Aber ich dachte eher an einen einfachen Prozedur-Aufruf, wie inc eben.

Also so was:

procedure BoolChange(var b: Boolean);

Klar kann man sich sowas ganz schnell selber basteln, ich wollte hat nur wissen, ob's sowas vielleicht schon in Delphi gibt.

[Airblader]

Ich hinterfrage mal den Sinn von einer selbigen, wenn es mit not doch viel einfacher ist :gruebel: ;)

air

[Martin K]

Naja, also vom Schreiben her geht's doch schneller:

b:= not b;

x(b);

Die Frage ist halt nur, ob's so eine Funktion gibt...

[marabu]

Hallo Martin,

man unterscheidet Funktionen, die zum Sprachumfang (System) zählen, von solchen die in einer (sonstigen) Unit deklariert werden. Zum Sprachumfang von Delphi (Object Pascal, Pascal) gehört eine solche Funktion nicht. Der Vorteil der Schreibersparnis - na ich weiß nicht so recht. Wenn, dann müsset die Funktion schon Negate() heißen.

Delphi-Quellcode:

function Negate(var b: Boolean): Boolean;
begin
  Result := b;
  b := not b;
end;

Ostergrüße vom marabu

[Martin K]

Hätte ja sein können, dass es so eine Prozedur in Delphi gibt (da gibt's ja sonst alles Mögliche)...

[3_of_8]

Oder einfach:

Delphi-Quellcode:

function Negate(var b: Boolean): Boolean;
begin
  Result:=not b;
end;

[marabu]

Manuel, ich sehe schwarz für deine Klausur...

marabu

[fkerber]

Hi!

@marabu und 3_of_8:
Warum eigentlich ne Funktion? Der Rückgabewert ist doch unnötig, oder?


Ciao Frederic

[faux]

Zitat:

Zitat von fkerber

@marabu und 3_of_8:
Warum eigentlich ne Funktion? Der Rückgabewert ist doch unnötig, oder?

Nicht nur das, imho ist er sogar falsch bei marabus Lösung.

Grüße
Faux

[fkerber]

Hi!

Nö, wieso?
Bei marabu steht nachher der negierte Wert in der Variable, sodass ein aufruf mit negate(x) möglich ist.
Bei 3_of_8 bewirkt negate(x) gar nix. Da müsste es dann x:=negate(x) heißen, was aber gänzlich unnötig wäre.


Ciao Frederic

[faux]

Zitat:

Zitat von fkerber

Bei marabu steht nachher der negierte Wert in der Variable, sodass ein aufruf mit negate(x) möglich ist.

...und der Rückgabewert ist nicht negiert.
Er hat zwar keine Anleitung mitgeliefert, aber ich finde es verwirrend, wenn dann der nichtnegierte Wert zurück kommt.

Grüße
Faux

[fkerber]

Hi!

Das iss richtig, aber weiter oben steht ja, dass der aufruf mit Negate(x) erfolgen solle.
Imho iss aber ein Rückgabewert hier sowieso unnötig.


Ciao Frederic

[SirThornberry]

eine funktion für soetwas ist alles andere als sinnvoll. Durch den Aufruf einer Funktion werden erst wieder die ganzen Dinge auf den Stack gepackt, dann wird zur Funktion hingesprungen etc. Also ein recht großer Performanceverlust und das nur wegen schreibfaulheit.

[faux]

Zitat:

Zitat von fkerber

Imho iss aber ein Rückgabewert hier sowieso unnötig.

Dazu habe ich mich noch garnicht geäußert. ;)
Ich finde das ganze Vorhaben etwas unnötig. :P Vorallem weil Negate(a); a:=not a; gleichviel, wenn nicht sogar mehr schreibaufwand ist. ;)

Grüße
Faux

[Martin K]

Um hier mal einzugreifen, ich meine ja eine Prozedur und keine Funktion, da man hier wirklich keinen Rückgabewert benötigt.
Inc() ist ja schließlich auch eine Prozedur und keine Funktion !

Delphi-Quellcode:

procedure Inc(var X: Integer);
begin
  X := X + 1;
end;

//analog dazu:
procedure Negate(var X: Boolean);
begin
  X := not X;
end;

Aber so eine Prozedur wollte ich ja gar nicht selber machen, sondern nur wissen, ob es sowas vielleicht in Delphi schon gibt.
Da dies aber nicht der Fall zu seien scheind, habe ich bereits:

Delphi-Quellcode:

X := not X;

in meinem Quelltext verwendet.

Eine Prozedur Negate scheint dann überflüssig zu sein, genauso wie Inc() in Delphi überflüssig ist, wenn man immer

Delphi-Quellcode:

X := X + 1;

verwendet !

Da es aber Inc() bereits in Delphi gibt, hätte es ja sein können, dass es auch so was wie Negate() schon gibt.
Eigentlich war ja nur das meine ursprüngliche Fragestellung !

Aber trotzdem finde ich es interessant, was sich für eine ausfürliche Diskussion aus dieser simplen Frage eintwickelt,
die eigentlich lediglich mit 'Ja' oder 'Nein' zu beantworten war.

[faux]

btw:

Die Inc Prozedur kann dann doch etwas mehr:

Delphi-Quellcode:

procedure Incx(var X: Ordinal; const N: Integer = 1);
begin
  X := X + N;
end;

Grüße
Faux

[fkerber]

Hi!

Zitat:

Zitat von Martin K

Eine Prozedur Negate scheint dann überflüssig zu sein, genauso wie Inc() in Delphi überflüssig ist, wenn man immer

Delphi-Quellcode:

X := X + 1;

verwendet !

Ich wage mal zu behaupten, dass die Funktion inc etwas anders funktioniert als x+1; und somit eine Performance-Steigerung bewirkt.


Ciao Frederic

[marabu]

Ja Martin, dass ist der Mehrwert eines Forums. Ja und Nein kann man anhand der Online-Hilfe klären, aber diese Diskussionen machen ein Forum interessant.

Die von mir gezeigte Funktion speichert den alten Wert, bevor sie den neuen Wert setzt - mit einer Zeile Code. Dadurch kann in einer Zeile der vorherige Wert ausgelesen und später wieder korrekt restauriert werden. So richtig sinnvoll ist das aber erst bei Typen, die mehr als zwei diskrete Werte kennen. Dort ist eine combined access method sehr angenehm, bei Boolean nehme auch ich in der Regel einfach den NOT Operator. Ihr müsst lernen das Wesentliche zu erkennen, auch wenn ihr nicht mit der Nase darauf gestoßen werdet.

Zum Thema Performanz: es dauert Jahre, bis man mit einer Programmiersprache ein Projekt in lesbarem und wartbarem Code formulieren kann. Für das Tuning kann ich Kollegen einsetzen, die die Fähigkeit lesbaren Code zu schreiben nicht besitzen. In den letzten 10 Jahren hatte ich nur zwei Projekte, bei denen explizites Tuning erforderlich war. Ihr dürft das Thema Performanz nie überbewerten. Erst muss eine Anwendung existieren, dann muss sie untersucht (Profiler) werden und dann werden die richtigen Stellen hand-optimiert - und nur die.

Freundliche Grüße vom marabu

[Martin K]

Na gut, wie auch immer.

Aber was bewirkt dann Inc(X) wenn X eine Boolean-Variable ist ?

[fkerber]

Hi!

Wenn x false ist, machts true draus, wenns schon true ist, dann bleibts true.


Ciao Frederic

[Chewie]

Sollte

Delphi-Quellcode:

x := Pred(x);

bzw.

Delphi-Quellcode:

x := Succ(x);

nicht das gewünschte bewirken?

true ist doch der Vorgänger von false, und auch der Nachfolger, da das ganze zyklisch ist.

[Hawkeye219]

Hallo Martin, hallo Chewie,

lest mal diesen Beitrag von himitsu.

Gruß Hawkeye

[Martin K]

Achso:
Inc, Pred und Succ bringt's dann nur bei ByteBool.

Bei einer Boolean-Variablen macht das nicht allzu viel Sinn,
da ich bei einfachen Boolean-Variablen mit Inc(x) das gleich bewirke wie mit x:=true;

[3_of_8]

Leute, habt Nachsicht mit mir. Ich hatte nur 5 Stunden Schlaf und hab schon seit Wochen nicht mehr richtig ausgeschlafen.

Delphi-Quellcode:

procedure negate(var b: Boolean);
begin
b:=not b;
end;

So.

(b:=negate(b); wäre irgendwie sinnlos, merke ich jetzt auch grad.)

[edit=SirThornberry]Delphi-Tags ergänzt. Mfg, SirThornberry[/edit]

[Khabarakh]

Zitat:

Zitat von Martin K

Inc, Pred und Succ bringt's dann nur bei ByteBool.

Zitat:

Bei einer Boolean-Variablen macht das nicht allzu viel Sinn,
da ich bei einfachen Boolean-Variablen mit Inc(x) das gleich bewirke wie mit x:=true;

Beide Aussagen sind falsch. Hast du dir himitsus Post wirklich durchgelesen :stupid: ?

[Martin K]

Zitat:

Zitat von Khabarakh

Zitat:

Zitat von Martin K

Inc, Pred und Succ bringt's dann nur bei ByteBool.

Zitat:

Bei einer Boolean-Variablen macht das nicht allzu viel Sinn,
da ich bei einfachen Boolean-Variablen mit Inc(x) das gleich bewirke wie mit x:=true;

Beide Aussagen sind falsch. Hast du dir himitsus Post wirklich durchgelesen :stupid: ?

Hä?
Dann hab ich wohl was falsch verstanden.
Also mich interresieren nur einfache Boolean-Variablen, also nur True oder False.

Hab's mal ausprobiert: Inc, Succ und Pred:
Egal, was meine Boolean-Variable vorher für einen Wert hatte, danach (bei allen drei) war sie immer TRUE.

Also kann ich doch auch eine einfache Zuweisung x:=true schreiben....

[Khabarakh]

Delphi-Quellcode:

var
  b: Boolean;
begin
  b := Boolean(High(Byte));
  Inc(b);
  Writeln(b);
  Readln;
end.

Nix ByteBool, nix dec, trotzdem False.
Auch wenn so etwas nicht häufig anzutreffen ist, sollte man sich der Grundlagen seines Tuns immer bewusst sein.

[DGL-luke]

wers unbedingt will und zwar ohne stackerhöhung, machts (ab D2005) so:

Delphi-Quellcode:

procedure Toogle(var b: Boolean); inline; //nb!
begin
b := not b;
end;

damit ersetzt der compiler den aufruf durch den code.