Eine Procedure erstellen Beispiel: procedure Removefile ...

[malo]

Was meinst du mit "Prozeduren registrieren"? WAS GENAU willst du machen?

Das was Nils beschrieben hat, ist eine Methode. Das ist wieder ein Thema für sich (OOP). Meist reicht jedoch prozeduale Programmierung, besonders für den Einstieg.

[Nils_13]

Zitat von malo:

Was meinst du mit "Prozeduren registrieren"? WAS GENAU willst du machen?

Das was Nils beschrieben hat, ist eine Methode. Das ist wieder ein Thema für sich (OOP). Meist reicht jedoch prozeduale Programmierung, besonders für den Einstieg.

In PASCAL muss man sie soweit ich weiß nur hinschreiben (ist lange her).

[BlackJack]

Zitat von Nils_13:

Zitat von malo:

Was meinst du mit "Prozeduren registrieren"? WAS GENAU willst du machen?

Das was Nils beschrieben hat, ist eine Methode. Das ist wieder ein Thema für sich (OOP). Meist reicht jedoch prozeduale Programmierung, besonders für den Einstieg.

In PASCAL muss man sie soweit ich weiß nur hinschreiben (ist lange her).

das ist in delphi nicht anders.

[Khabarakh]

Zitat von malo:

Meist reicht jedoch prozeduale Programmierung, besonders für den Einstieg.

Ich würde mal sagen, eine Methode ist hier völlig unpassend . Jedenfalls bei der Form-Klasse.

@mindforce:
Der Code der Funktion steht im implementation-Teil deiner Unit, das ist die Implementation der Funktion. Du kannst den Funktionskopf in den interface-Abschnitt kopieren, dann hast du eine global deklarierte Funktion. Nicht-globale Funktionen kannst du nur in der gleichen Unit und nur in Code unter der Implementation aufrufen. Globale Funktionen kannst du in der gesamten Unit und in Units, in deren uses-Liste deine Unit steht, aufrufen.

[alcaeus]

Hallo ihr,

also...das was Nils da gebaut hast ist eine Methode einer Klasse. Diese kann nur angewendet werden, falls man eine Instanz der Klasse (in diesem Fall Form1) hat. Aufrufkonvention:

Delphi-Quellcode:

<Objektvariable>.<MethodenName>
//Oben z.B.:
Form1.RemoveFile;

Je nachdem wo man sie deklariert sind sie "mehr oder weniger sichtbar". Eine Funktion, die im private-Bereich deklariert wurde, wird nur in der eigenen Unit aufrufbar sein. Im public-Bereich hingegen ist sie fuer alle sichtbar.

Das zweite sind "normale" Funktionen/Prozeduren, welche es ja auch schon im guten alten DOS-Pascal gab. Es gibt mehrere Wege diese zu implementieren:

• Einfache implementierung ohne interface-Deklaration: Die Funktionen werden einfach im implementation-Teil geschrieben, z.B.:
  
  Delphi-Quellcode:

  unit Foo;
  interface
  implementation
  
  function Bar: Integer;
  begin
    Result := 42;
  end;
  
  end.

  Diese Funktionen sind nur in der eigenen Unit sichtbar, aber auch nur nachdem sie deklariert wurden. Dies wuerde also zu einem Fehler fuehren:
  
  Delphi-Quellcode:

  unit Foo;
  interface
  implementation
  
  function Bar: Integer;
  begin
    Result := FooBar;
  end;
  
  function FooBar: Integer;
  begin
    Result := 42;
  end;
  
  end.

• Implementierung mit vorhergehender Deklaration: Dabei wird der Funktionskopf im interface-Teil deklariert, die Implementierung erfolgt wie vorhin im implementation-Teil:
  
  Delphi-Quellcode:

  unit Foo;
  interface
  
  function Bar: Integer;
  
  implementation
  
  function Bar: Integer;
  begin
    Result := 42;
  end;
  
  end.

  Die Funktionen sind dabei auch ausserhalb der Unit sichtbar. Weiters sind die Funktionen bereits deklariert, also wuerde dieser Code diesmal funktionieren:
  
  Delphi-Quellcode:

  unit Foo;
  interface
  
  function Bar: Integer;
  function FooBar: Integer;
  
  implementation
  
  function Bar: Integer;
  begin
    Result := FooBar;
  end;
  
  function FooBar: Integer;
  begin
    Result := 42;
  end;
  
  end.

• Forward-Deklaration von Funktionen: Wir haben vorhin gesehen, dass Funktionen, welche im implementation-Teil implementiert werden, ohne vorher deklariert zu werden, erst nach der Funktion selbst "sichtbar" sind. Was tun wenn die Prozeduren nur in der Unit sichtbar sein sollen, aber trotzdem der zweite Code aus dem ersten Abschnitt funktionieren soll? Dafuer gibt es das Schluesselwort forward:
  
  Delphi-Quellcode:

  unit Foo;
  interface
  implementation
  
  function Bar: Integer; forward;
  function FooBar: Integer; forward;
  
  function Bar: Integer;
  begin
    Result := FooBar;
  end;
  
  function FooBar: Integer;
  begin
    Result := 42;
  end;
  
  end.

  Das Schluesselwort forward sagt dem Compiler, dass die Funktion hier nur deklariert wurde, die Implementierung aber spaeter folgt. So sind die Funktionen ausserhalb der Unit nicht sichtbar, aber der Aufruf von FooBar in Bar funktioniert trotzdem.

So, ich hoffe das Tippen hat sich wenigstens gelohnt und die Tipps helfen (ok..einen Teil hat Khabarakh schon erklaert, aber meins ist genauer )

Greetz
alcaeus

[Khabarakh]

Zitat von alcaeus:

So, ich hoffe das Tippen hat sich wenigstens gelohnt und die Tipps helfen (ok..einen Teil hat Khabarakh schon erklaert, aber meins ist genauer )

Sagen wir lieber "etwas ausformulierter und mit Praxisbeispielen anschaulich gemacht" . Gut, der forward-Teil fehlt bei mir komplett, wenn ich ehrlich bin, hatte ich es bis zu diesem Moment noch nie gesehen .
Jetzt aber alles komplett? Nö, Klassenmethoden fehlen noch :

Delphi-Quellcode:

TMyUsefulWindowsMethods = class
  public
    class procedure RemoveFile;
  end;

Aufruf:
TMyUsefulWindowsMethods.RemoveFile Das wäre eine sinnvolle Kapselung als Klasse.

[mindforce]

Vielen Dank. Dies ist mir wirklich gut erklärt worden:

Zitat:

Zitat von Nils_13:

hi,

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
--> function RemoveFile(const Filename: String): DWORD; <--
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

--> function TForm1.RemoveFile(const Filename: String): DWORD;
begin
  result := Windows.DeleteFile(PChar(Filename));
end; <--

end.

Der Code läfut zwar nicht, es soll dir ja auch nur erklären, wie es läuft.

und

Zitat:

Meist reicht jedoch prozeduale Programmierung, besonders für den Einstieg.

Ich würde mal sagen, eine Methode ist hier völlig unpassend . Jedenfalls bei der Form-Klasse.

@mindforce:
Der Code der Funktion steht im implementation-Teil deiner Unit, das ist die Implementation der Funktion. Du kannst den Funktionskopf in den interface-Abschnitt kopieren, dann hast du eine global deklarierte Funktion. Nicht-globale Funktionen kannst du nur in der gleichen Unit und nur in Code unter der Implementation aufrufen. Globale Funktionen kannst du in der gesamten Unit und in Units, in deren uses-Liste deine Unit steht, aufrufen.

.