Die größer Zahl nehmen ?

[thomas2009]

Hallo

kann man in Delphi die direkt die größer zahl nehmen ?

ich möchte nicht folgendes machen

Delphi-Quellcode:

if x > y then begin z:=x; end else begin z:=y; end:

Sondern z:=groesser(x;y):

Oder gibt es sowas in delphi nicht ?

[DeddyH]

Max (Unit math, glaube ich).

[Meflin]

http://www.delphibasics.co.uk/RTL.asp?Name=Max

[Matze]

Hi,

nur als Ergänzung, damit du siehst, was es tolles in Delphi gibt: Man kann selbst Funktionen schreiben. :stupid:

Delphi-Quellcode:

function groesser(const a, b: Integer): Integer;
begin
  if a > b then
    Result := a
  else
    Result := b;
end;

Das ist ungetestet. Der Aufruf (fast so wie du es möchtest):

Delphi-Quellcode:

z := groesser(x, y):

Das gilt nun für Integer-Zahlen (ganze Zahlen).

Grüße, Matze

[himitsu]

und damit du siehst wie gut deine If-Abfrage war :angel:

die eine Max-Funktion aus der Unit Math

Delphi-Quellcode:

function Max(const A, B: Integer): Integer;
begin
  if A > B then
    Result := A
  else
    Result := B;
end;

[thomas2009]

Mit der Funktion geht auch aber Delphi macht dach von alleine

Max(3,11):=11;

Danke

[Meflin]

Zitat:

Zitat von thomas2009

Mit der Funktion geht auch aber Delphi macht dach von alleine

Max(3,11):=11;

Was soll da hießen "von alleine"? Das macht garnix von alleine. Max ist einfach nur eine Funktion, die mitgeliefert wird. Ob du die verwendest oder eine selbstgeschriebene ist Jacke wie Hose - beides ist nicht "von alleine".

[Matze]

Die Frage ist immer, ob es sich lohnt, eine große Mathematik-Unit einzubinden für eine noch so einfache Funktion.
Aber gut, die Dateigröße spielt heute kaum mehr eine Rolle und von der Geschwindigkeit her wird es ähnlich sein.

Aber es ist richtig, was Meflin sagt und es wäre gut, wenn du das auch verstehen würdest, denn solche Grundlagen sind immer hilfreich.

PS: Lustig, mein runter getippter Code oben nahezu identisch mit dem der Math-Unit, sehe ich gerade (Bezeichner, Formatierung).

Grüße, Matze

[himitsu]

nja, die Math-Unit selber braucht nicht mehr platz, als man davon verwendet (keine Initialisierung vorhanden) ... nja, außer daß sie die rießige Unit SysUtils einbindet ... aber wenn man diese Unit eh schon drin hat, isses hier egal :stupid:

[Sir Rufo]

Zitat:

Zitat von Meflin

Zitat:

Zitat von thomas2009

Mit der Funktion geht auch aber Delphi macht dach von alleine

Max(3,11):=11;

Was soll da hießen "von alleine"? Das macht garnix von alleine. Max ist einfach nur eine Funktion, die mitgeliefert wird. Ob du die verwendest oder eine selbstgeschriebene ist Jacke wie Hose - beides ist nicht "von alleine".

doch ... strom kommt aus der steckdose und geld kommt vom konto ... dann ist ja alles klar ... :stupid:

[Laufi]

Hallo!

Wenn Du es ganz krass machen willst kannst du es auch so machan :shock: :lol:

Delphi-Quellcode:

function Max(const A, B: Integer): Integer;
asm
  CMP EAX, EDX;
  CMOVL EAX, EDX;
end;

Liebe Grüsse Laufi

[globetrotter77]

@Laufi:

wenn schon, dann

Delphi-Quellcode:

type irgendwas = Integer;
     nochmalwas = irgendwas;
function tu_mal_was_von_alleine_und_frag_nicht_lange_nach_dem_sinn_von_dem_ganzen((const kleine_oder_grosse_zahl, grosse_oder_kleine_zahl: irgendwas): nochmalwas;

[Cyf]

Zitat:

Delphi-Quellcode:

function Max(const A, B: Integer): Integer;
begin
  if A > B then
    Result := A
  else
    Result := B;
end;

[OFFTOPIC]Warum ist hier eigentlich das const sinnvoll? Übergibt man die Zahlen direkt sind sie je 4 Bytes groß, ein Pointer der zusätzlich noch dereferenziert werden muss, ist das je auch. Theoretisch ist das doch unnötiger zusätzlicher Aufwand - ja klar es ist nicht wirklich spürbar und zudem, trotzdem die selbe Anzahl Opcodes (vermutlich, ungetestet), allerdings müsste ja ein direkter Wert (in meiner Logik) dennoch schneller sein als dereferenzieren? Und natürlich gibt es auch noch den schlichten Punkt, dass ein const Programmierfehler verhindern kann.

[Cyf]

Zitat:

Zitat von Laufi

Hallo!

Wenn Du es ganz krass machen willst kannst du es auch so machan :shock: :lol:

Delphi-Quellcode:

function Max(const A, B: Integer): Integer;
asm
  CMP EAX, EDX;
  CMOVL EAX, EDX;
end;

Liebe Grüsse Laufi

Vergleichst du hier nicht Adressen?

[Laufi]

Du meinst wegen dem const? Nein das ist ihm gleich bei den kleinen typen :o

[globetrotter77]

Zitat:

Warum ist hier eigentlich das const sinnvoll?

Ist mir auch nicht ganz klar, und ich würde es auch nicht machen.
Die Online-Hilfe ist in solchen Fällen leider gar nicht mehr hilfreich.

[Laufi]

Er übergibt nur bei grossen typen die adresse wenn man const schreibt, er ist ja nicht dumm! Das const macht also nichts langsamer es ist nur zur schutz für den Programmierer :roll:

[Cyf]

Zitat:

Zitat von Laufi

Er übergibt nur bei grossen typen die adresse wenn man const schreibt, er ist ja nicht dumm! Das const macht also nichts langsamer es ist nur zur schutz für den Programmierer :roll:

Hmm, das macht dann natürlich mehr Sinn (auch wenn man dann bei asm auch noch nachdenken muss :wink: ). Ich teste das morgen mal kurz für mich, mir jetzt zu spät.

[himitsu]

ist entweder drin, weil es bei den anderen Max-Funktionen auch drin ist ... sieht einheitlicher aus
und eventuell könnte es vorteile für den Inline-Code haben.

PS: die Pascalversion ist am Ende schneller, als das ASM von dort oben, da in Delphi diese Funktion als INLINE-Code defniert ist.
heißt, im Programm gibt es diese Funktion dann nicht, da der Vergleich direkt vor Ort in deinen Quellcode integriert wird.
(bei dem ASM gibt es diese Funktion, wo erst hin- und dann wieder zurückgesprungen werden muß)

[sirius]

In D7 ist es kein inline (gibts das hier überhaupt?)

[himitsu]

also seit 'ner Weile gibt's das wieder (weiß nicht genau, seit D2006 auf jeden Fall)

[Matze]

Zitat:

Zitat von Cyf

Warum ist hier eigentlich das const sinnvoll?

Das ist eine gute Frage. Wie du siehst habe ich es in "meiner" Funktion ebenfalls verwendet.
Es gab hier mal ein Thema (vielleicht gibt es das auch noch), im dem der Sinn des Ganzen beschrieben war. Seitdem habe ich mir gemerkt, wenn die Parameter-Werte in der Funktion nicht verändert werden, ein "const" davor zu setzen.

Mich würde es jedoch auch interessieren, wieso genau ich das davor setze. :mrgreen: Vielleicht bin ich zu gutgläubig.

Grüße, Matze

[DeddyH]

Bevor ich mir hier den Wolf tippe:

Zitat:

Zitat von Delphi 7-Hilfe

Wert- und Variablenparameter
Die meisten Parameter sind Wert- (Standard) oder Variablenparameter (var). Wertparameter werden als Wert übergeben, Variablenparameter als Referenz. Der Unterschied wird anhand der folgenden beiden Funktionen deutlich:

Delphi-Quellcode:

function DoubleByValue(X: Integer): Integer;     // X ist ein Wertparameter
begin
  X := X * 2;
  Result := X;
end;
function DoubleByRef(var X: Integer): Integer;***// X ist ein Variablenparameter
begin
  X := X * 2;
  Result := X;
end;

Diese Funktionen liefern das gleiche Ergebnis. Nur die zweite Funktion (DoubleByRef) kann jedoch den Wert der an sie übergebenen Variablen ändern. Die Funktionen können beispielsweise folgendermaßen aufgerufen werden:

Delphi-Quellcode:

var
  I, J, V, W: Integer;
begin
  I := 4;
  V := 4;
  J := DoubleByValue(I);   // J = 8, I = 4
  W := DoubleByRef(V);     // W = 8, V = 8
end;

Nachdem diese Anweisungen ausgeführt wurden, enthält die an DoubleByValue übergebene Variable I immer noch den ursprünglichen Wert. Die an DoubleByRef übergebene Variable V enthält dagegen einen neuen Wert.

Ein Wertparameter verhält sich wie eine lokale Variable, die durch den im Aufruf der Funktion oder Prozedur übergebenen Wert initialisiert wird. Wenn Sie eine Variable als Wertparameter übergeben, erstellt die Prozedur oder Funktion eine Kopie dieser Variablen. Änderungen des Wertes dieser Variablen wirken sich nicht auf die ursprüngliche Variable aus.

Sie werden verworfen, sobald die Steuerung wieder an den Aufrufer zurückgegeben wird. Ein Variablenparameter ist dagegen mit einem Zeiger vergleichbar. Änderungen des Parameters im Rumpf einer Prozedur oder Funktion bleiben deshalb erhalten, wenn die Programmausführung wieder dem Aufrufer übergeben wird und der Parametername nicht mehr im Gültigkeitsbereich liegt.

Auch wenn dieselbe Variable in mehreren var-Parametern übergeben wird, werden keine Kopien erstellt. Dieses Merkmal wird im folgenden Beispiel illustriert:

Delphi-Quellcode:

procedure AddOne(var X, Y: Integer);
begin
  X := X + 1;
  Y := Y + 1;
end;
var I: Integer;
begin
  I := 1;
  AddOne(I, I);
end;

Nachdem dieser Code ausgeführt wurde, enthält die Variable I den Wert 3.

Enthält die Deklaration einer Routine einen var-Parameter, müssen Sie im Aufruf der Routine einen Ausdruck übergeben, dem ein Wert zugewiesen werden kann, also eine Variable, eine typisierte Konstante (im Status {$J+}), einen dereferenzierten Zeiger, ein Feld oder eine indizierte Variable. Im Beispiel weiter oben würde DoubleByRef(7) einen Fehler generieren, während der Aufruf DoubleByValue(7) zulässig wäre.

In var-Parametern (beispielsweise DoubleByRef(MyArray[I])) übergebene Indizes und dereferenzierte Zeiger werden vor der Ausführung der Routine einmal ausgewertet.


Konstantenparameter
Ein Konstantenparameter (const) entspricht einer lokalen bzw. schreibgeschützten Variablen. Konstantenparameter entsprechen weitgehend Wertparametern. Sie können ihnen jedoch im Rumpf einer Prozedur oder Funktion keinen Wert zuweisen und sie nicht als var
-Parameter an eine andere Routine übergeben. Übergeben Sie eine Objektreferenz als Konstantenparameter, können Sie weiterhin auf die Objekteigenschaften zugreifen und diese ändern.

Die Verwendung von const ermöglicht dem Compiler die Optimierung des Codes für strukturierte und String-Parameter. Gleichzeitig wird die versehentliche Übergabe eines Parameters als Referenz an eine andere Routine verhindert.

Das folgende Beispiel ist der Header der Funktion CompareStr in der Unit SysUtils:

Delphi-Quellcode:

function CompareStr(const S1, S2: string): Integer;

Da S1 und S2 im Rumpf von CompareStr nicht geändert werden, können sie als Konstantenparameter deklariert werden.

[edit]

Zitat:

Bevor ich mir hier den Wolf tippe:

Sorry, Chäffe, das Wortspiel ist mir selbst erst später aufgefallen :lol: [/edit]

[himitsu]

solange man bei einem Integer/LongInt/SmallInt/ShortInt/Cardinal/LongWord/Word/Byte/Boolean mit Var/Out arbeitet, wird eine Refferenz übergeben ... wenn man Const oder nichts übergibt, dann wird (zumindestens bei der Konvention PASCAL ... bei den anderen weiß ich es jetzt nicht) nur der Inhalt koppiert da dieses in der Verarbeitung schneller ist ... muß dann ja nur noch aus dem Variablenspeicher gelesen und nicht erst die Referenz aufgelöst werden.

Vorallem bei größeren Typen wird bei Const/Var/Out die Referenz übergeben und ohne eine Angabe eine Kopie des Inhalts angelegt und damit geareitet.
für IN bin ich mir grad nicht ganz sicher.

Sozusagen: in Delphi gibt es in der Standardaufrufkonvention und bei vielen Typen kleiner-gleich Integer eigentlich keinen Unterschied zwischen Const oder Nichts ... aber es kann auch nicht schaden, wenn man es macht ... wenn man es immer macht, vergißt man es nicht bei Typen, wo es besser wär :stupid:

[globetrotter77]

Wenn ich es richtig verstanden habe, meckert der Compiler also, wenn ich aus proc1(Const a: xy)
eine proc2(var b:yz) mit meinem konstanten Parameter aufrufe.

Das war früher anders. Da konnte man sowas machen und in der Procedure proc1 mit dem veränderten Parameter weitermachen, aber eben nur intern! An die ursprüngliche Aufrufstelle wurde dann keine Veränderung zurückgegeben.

So gesehen, macht das durchaus Sinn!

[himitsu]

wie, das ginge früher mal?

weder in D7 noch Neuer geht's

Delphi-Quellcode:

procedure Test2(var x: Integer);
begin
  x := 123;
end;

procedure Test1(const x: Integer);
begin
  Test2(x);  // [Fehler] Unit1.pas(32): Konstantenobjekt kann
end;         // nicht als Var-Parameter weitergegeben werden

procedure TForm1.FormCreate(Sender: TObject);
begin
  Test1(Tag);
end;

man kann es sich so vorstellen (von der Verwendung her):
mit Const ist der Parameter wie eine Konstante
ohne Const ist es wie eine lokale Vaiable, welche beim Prozedurstart vorbelegt wurde

[globetrotter77]

Zitat:

Zitat von himitsu

wie, das ginge früher mal?

war wohl etwas flapsig formuliert ... ich meinte eine procedure, in der kein const angegeben ist.
Außerdem meine ich mit früher sowas wie Turbo Pascal, da kommt das ja alles her. und das kannte auch keine const-Angabe bei den Parametern.

Zitat:

man kann es soe so vorstellen (von der Verwendung her)
mit Const ist der Parameter wie eine Konstante
ohne Const ist es wie eine lokale Vaiable, welche beim Prozedurstart vorbelegt wurde

das dürfte die richtige Formulierung sein!

[globetrotter77]

und das geht auch heute noch! gerade ausprobiert!

wenn dagegen const dabei steht, gibt es ne Fehlermeldung vom Compiler:
E2197 Konstantenobjekt kann nicht als Var-Parameter weitergegeben werden

[himitsu]

ja klar, ohne CONST ist es ja keine Konstante mehr und darf verändert werden.