Deklarierung einer "function"

[mindforce]

Da ich noch sehr jung bin, weiss ich natürlich nicht sooooo viel von Delphi. Aber das einzige was ich nicht verstehe kann mir kein Schwein beibringen :wall: . Undzwar die Deklarierung von "function"´s.
Wie man eine "procedur" erstellt weiss ich seltsamer weise: Doppelklick auf Item, schon hat er mir eine "procedure" erstellt die ich auch dann in der Unit bearbeiten kann. :roll:
Aber wie man eine "function" erstellt bzw. deklariert kann mir das vieleicht jemand erklären????? :oops:

Vielen Dank für eure mithilfe.

Achso: Bei meinem letztem beitrag habe ich diese Antwort bekommen:

Zitat:

Zitat von Robert Marquardt

Bewirb dich bei einer Abbruchfirma.

Aber es geht noch ein Dank an Brainshock der folgendes geschreiben hat:

Zitat:

Zitat von Brainshock

Die Webseiten von "mindforce" sind auch mal einen Besuch wert!
:thumb: :wink:

Delphi Praxis - Wallbreaker
Hoffe das der Link funzt!

-------------------------

Danke für die Antworten. Ich werde es mal ausprobieren.

[Matze]

Hallo

Schau in die Open-Source SParte und siehe dier Quelltexte an. ;)

Hier mal ein kleines Beispiel:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
    // Hier wäre es so "richtig" global deklariert
    // Aufrufen könntest du hier deklarierte Funktionen einfach über ihren Namen
    // und das in jeder Unit, die diese Unit hier eingebunden hat

  private
    { Private-Deklarationen }

    // Nur in dieser Unit sichtbar
    // Man muss sie hier nicht deklarieren, wenn du die Funktion über denen
    // implementiert, die diese Aufrufen
    procedure Foo(A: Integer);
    function Blubb(A: String): Integer;

  public
    { Public-Deklarationen }

    // im ganzen Programm sichtbar
    // Aufruf über
    // Form1.xyz
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

// Prozedur
procedure TForm1.Foo(A: Integer);
begin
  ShowMessage(IntToSTr(A));
end;

// Funktion
function TForm1.Blubb (A: String): Integer;
begin
  result := Length(A);
end;

end.

[malo]

Ich empfehle dir auch Das ;)

[emteg]

Zitat:

Aber wie man eine "function" erstellt bzw. deklariert kann mir das vieleicht jemand erklären?????

Ist ganz einfach: eine function ist eine procedure, die einen wert zurückliefert. Genau wie procedures, kannst du das beliebig in deinen quelltext reinpacken:

Delphi-Quellcode:

type
  TForm1 = class(TForm)
  procedure ZeigeNachricht(Text: string);
  function Addieren(a: integer; b: integer): integer;
  private
    { Private declarations }
  public
    { Public declarations }
  end;

{...}

procedure TForm1.ZeigeNachricht(Text: string);
begin
  ShowMessage(Text);
end;

function TForm1.Addieren(a: integer; b: integer): integer;
begin
  Result:=0;       //Bei functions wird das ergebnis über die feste variable Result gesetzt.
  Result:=a+b;
end;

Jede function oder procedure, die du selbst definieren möchtest, schreibst du beim type TForm1 einfach rein. Im quelltext musst du bei fenstern noch den namen der unit dazu schreiben. Also in diesem Fall "TForm1." Bei functions sollte man auf jedenfall dem result einen default wert zuweisen, falls irgendetwas schief geht.
Aufrufen kannst du eine function so:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObejct);
begin
  Edit3.Text:=IntToStr(Addieren(StrToInt(Edit1.Text), StrToInt(Edit2.TExt));
end;

Ich hoffe mal, ich konnte dir helfen.

[tigerman33]

Das wichtigste ist ja eigentlich schon gesagt worden, aber trotzdem werd ich mal meine 2 cent noch einbringen.

Du unterliegst da einem leichten Irrtum was die procedures angeht. Natürlich hast du recht, dass eine procedure erstellt wird, wenn du doppelt auf eine Komponente klickst. Das ist aber nur ein Teil der Wahrheit. Procedures und Functions kannst du nämlich ebensogut "von Hand" erstellen (und dies wird in den meisten Situationen auch der Fall sein).
Prozeduren und Funktionen sind dazu da, dein Programm in logische Blöcke aufzuspalten. Anstatt alles in eine einzige Hauptprogrammroutine zu schreiben fasst du gewissermaßen zusammen was zusammen gehört. Das macht deinen Quelltext übersichtlicher und auch wiederverwertbarer, weil du gleiche oder ähnliche Dinge nicht mehrmals eintippen musst.

Damit ist denke ich plausibel, dass es zum größten Teil dir überlassen ist, wo und wann du eine procedure/function schreibst. Was die Details zur Deklaration etc angeht verweise ich auf meine Vorredner. :wink:

[ichbins]

Du kannst eine Funktion oder Prozedur so erstellen:

Entweder, sie gehört dierekt zur Unit, dann deklarierst du sie ausserhalb irgendwelcher Klassendeklarationen:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

procedure myprocedure(i:integer);
function myfunction(i:integer):string;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure myprocedure(i:integer);
begin
  dosomething;
end;

function myfunction(i:integer):string;
begin
  dosomethingother;
end;

end.

oder du deklarierst die Funktion/Klasse zu einer Klasse zugehörig, in unserem Falle also TFORM1:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    procedure myprocedure(i:integer);
    function myfunction(i:integer):string;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure tform1.myprocedure(i:integer);
begin
  dosomething;
end;

function tform1.myfunction(i:integer):string;
begin
  dosomethingother;
end;

end.

welche Methode von beiden empfehlenswerter ist, überlasse ich dir. Wenn du von der Prozedur/Funktion aus dierekten Zugriff auf die form haben willst (z.B. canvas.rectangle oder label1.caption aufrufen willst, dann solltest du sie in der Form deklarieren, wenn du mehrere Units verwendest, unbedingt ausserhalb der form. Wenn du sie ausserhalb der form deklarierst, musst du label1.caption so aufrufen: form1.label1.caption (da form1 eine Variable ist, die dierekt in der Unit deklariert ist) oder so:

Delphi-Quellcode:

procedure xy;
begin
  with form1 do 
  begin
    dosomething;
  end;
end;

[Khabarakh]

Zitat:

Zitat von emteg

Genau wie procedures, kannst du das beliebig in deinen quelltext reinpacken:

Delphi-Quellcode:

type
  TForm1 = class(TForm)
  procedure ZeigeNachricht(Text: string);
  function Addieren(a: integer; b: integer): integer;
  private
    { Private declarations }
  public
    { Public declarations }
  end;

{...}

Kann man eben nicht. Eine selbstgeschriebene Methode hat nichts unter published zu suchen.
@mindforce: Es gibt generell zwei Typen von Prozeduren: lokale Prozeduren und Methoden. Erstere stehen irgendwo unter implementation. Vereinfacht kann man sagen, dass du hier nicht auf die Formcontrols zugreifen kannst/sollst:

Delphi-Quellcode:

function Add(const a, b: Integer): Integer;
begin
  Result := a + b;
  // Result := StrToInt(Edit1.Text) + a + b 
  // geht nicht, bzw. nur über hässliche Irrwege
end;

Außerdem kann man nur in Code unterhalb der Funktion auf diese zugreifen.
Methoden gehören zu deiner Form, du kannst problemlos auf alle Controls der Form zugreifen. Soll die Methode auch von anderen Units/Klassen aufgerufen werden, deklarierst du sie unter public, sonst private.

Delphi-Quellcode:

TForm1 = class(TForm)
private
  function Add(const a: Integer): Integer;
public
  [...]

Den Code schreibst du nun unter implementation, wobei du den Klassennamen vor den Funktionsnamen hängst (bestimmt die Zugehörigkeit der Methode) oder einfach im type-Abschnitt Strg + Shift + C drückst:

Delphi-Quellcode:

function TForm1.Add(const a: Integer): Integer;
begin
  Result := StrToInt(Edit1.Text) + a;
end;

Das war jetzt ziemlich vereinfacht, Genaueres musst du aber erst wissen, wenn du dich intensiver mit OOP beschäftigst.

Zitat:

Im quelltext musst du bei fenstern noch den namen der unit dazu schreiben.

Erstens gilt das für alle Klassen, zweitens ist es der Klassenname.

Zitat:

Bei functions sollte man auf jedenfall dem result einen default wert zuweisen, falls irgendetwas schief geht.

Wenn eine Exception geworfen wird, muss das Ergebnis der Funktion als ungültig betrachtet werden. Etwas wie

Delphi-Quellcode:

function TForm1.Addieren(a: integer; b: integer): integer;
begin
  Result:=0;
  Result:=a+b;
end;

ist völlig unsinnig.

[edit]ichbins war schneller :stupid: [/edit]

[ichbins]

Zitat:

Zitat von Khabarakh

...oder einfach im type-Abschnitt Strg + Shift + C drückst:

unter D2005 vllt, aber schon unter D4? unter D3 konnte man ja nochnicht einmal scrollen :?

[Khabarakh]

Zitat:

Zitat von ichbins

Zitat:

Zitat von Khabarakh

...oder einfach im type-Abschnitt Strg + Shift + C drückst:

unter D2005 vllt, aber schon unter D4?

Keine Ahnung, auf jeden Fall ab D6 (AFAIK aber nur für die > Personal-Versionen).