Entwickler-Ecke :: Thema anzeigen - Komische Procedur deklaration!!! Was ist das?

spoof - So 10.11.13 01:08
Titel: Komische Procedur deklaration!!! Was ist das?

Ich hab Fragen zu Prozeduren, ich kenne es bisher nur so dass man eine Prozedur so benutzt:

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

procedure TForm1.BT_LoginClick(Sender: TObject);  // <--------------------------
var
loginuser,loginpw,code,code2:string;
loginusercount,loginpwcount,loginuserverschlüsselt,loginpwverschlüsselt,i,j:integer;
begin

loginuser:=ED_Loginuser.Text;
loginpw:=ED_Loginpw.Text;
Ini:=TIniFile.Create('C:\Iniprogramm\login.ini');
loginuserverschlüsselt:=0;
loginpwverschlüsselt:=0;

usw...

Jetzt seh ich aber bei Tutorials immer öfter sowas

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:

procedure OpenDrive(AOpen: Boolean);  // <--------------------------
const
  OpenStr: array[False..True] of string = ('closed', 'open');
begin
  mciSendString(PChar('Set cdaudio door ' + OpenStr[AOpen] + ' wait'), nil, 0, 0);
end;
usw...

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

procedure Out32(PortAddress: smallint; Value: smallint); stdcall; export;  // <--------------------------
var
  ByteValue: Byte;
begin
  ByteValue:=Byte(Value);
  asm
    push dx
    mov dx,PortAddress

usw...

Was hat es mit den Kommentierten Zeilen aufsich?

Wie man beim ersten der 3 Fälle sehen kann ist das eine normale buttonfunction die beim click ausgeführt wird,die anderen 2 versteh ich nicht das is meine Frage, was haben die Procedur Zeilen zu bedeuten? Wieso wird da in der Klammer deklariert? Wo ist der Sinn dabei und warum macht man das und was bringt das oO ?

Tranx - So 10.11.13 07:46

Die Frage ist etwas unklar. Du hast bei Prozeduren (suche dies mal in der Delphi-Hilfe) die Möglichkeit, entweder gar keine Parameter zu übergeben, oder einen oder mehrere. Dazu noch die verschiedensten Variablentypen als Parameter. Sender ist im ersten Fall das Objekt, welches die Prozedur aufruft (z.B. Dein Button). Im zweiten Fall übergibst Du eine boolsche Variable als Parameter. Das sind zumeist selbst geschriebene Prozeduren. Ein Beispiel für mehrere Parameter sit eine OnKeyDown-Prozedur (z.B. einer TEdit-Komponente):

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

Deklaration im Formular Form1:

    procedure Edit1KeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);


Aufruf:

     procedure TForm1.Edit1KeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
     begin
     end;

Hier hast Du sowohl Sender, als auch Key und Shift. Key muss eine Variable sein, die Du übergibst (deswegen Var vorangestellt) , und Shift kann auch ein fester Wert sein.

Der dritte Fall ist zusätzlich mit Direktiven versehen. Diese beschreiben (stdcall z.B., ob die Prozedur die Parameter auf Register des Prozessors ablegt oder nicht, export hat heute keine Bedeutung mehr, galt nur für 16-bit-Systeme (wo die Adressräume unterschiedlich angesprochen wurden)

Rufe mal "Parameter" unter der Delphi-Hilfe auf.

Delete - So 10.11.13 09:35

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

uses MMSystem;

procedure OpenDrive(AOpen: Boolean);  // <--------------------------
const
  OpenStr: array[False..True] of string = ('closed', 'open');
begin
  mciSendString(PChar('Set cdaudio door ' + OpenStr[AOpen] + ' wait'), nil, 0, 0);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
   OpenDrive(true); //öffnet CD-Laufwerk
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
   OpenDrive(false); //schliesst CD-Laufwerk, falls mechanisch möglich
end;

WasWeißDennIch - So 10.11.13 10:53

Außerdem gibt es einen Unterschied zwischen Methoden und den sog. regulären Prozeduren/Funktionen. Eine Methode gehört immer zu einer Klasse bzw. einer Instanz davon, z.B.:

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

type
  TDings = class
    (* Deklaration der Methode Bums der Klasse TDings *)
    procedure Bums;
  end;

(* Prototyp der regulären Prozedur Wuppdi *)
procedure Wuppdi;

implementation

(* Implementation der Methode, der Klassenname ist zwingend voranzustellen *)
procedure TDings.Bums;
begin
  ...
end;

(* Implementation der Prozedur Wuppdi ohne Klassennamen (welchen denn auch?) *)
procedure Wuppdi;
begin
  ...
end;

Lemmy - So 10.11.13 11:15

spoof hat folgendes geschrieben :

Delphi-Quelltext

1:
2:
3:

procedure TForm1.BT_LoginClick(Sender: TObject);  // <--------------------------
var
usw...

das ist streng genommen keine Prozedur sondern eine Methode der Klasse TForm1. Methode = Funktion oder Prozedur einer Klasse

spoof hat folgendes geschrieben :

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:

procedure OpenDrive(AOpen: Boolean);  // <--------------------------
const
  OpenStr: array[False..True] of string = ('closed', 'open');
begin
  mciSendString(PChar('Set cdaudio door ' + OpenStr[AOpen] + ' wait'), nil, 0, 0);
end;
usw...

das ist jetzt eine Prozedur. Sozusagen eine "globale Methode" - also wie bei globalen Variabeln ohne Zusammenhang zu einer Klasse.

spoof hat folgendes geschrieben :

Delphi-Quelltext

1:
2:

procedure Out32(PortAddress: smallint; Value: smallint); stdcall; export;  // <--------------------------
usw...

Was sagt F1 beim "Export"? http://docwiki.embarcadero.com/RADStudio/XE5/de/Prozeduren_und_Funktionen

stdcall und export sind sogenannte Aufrufkonventionen, die im Zusammenhang mit DLLs auftauchen...

Grüße

Delete - So 10.11.13 12:28

hathor hat folgendes geschrieben :

Gewöhne Dir mal an, fehlerfrei zu schreiben, sonst wird das mit dem Programmieren NIE etwas!

Wem antwortest du hier? Bei Antworten sollte man meiner Ansicht nach kennzeichnen, an wen sich diese richtet, sonst sieht es hier nämlich so aus, als würdest du mir Rechtschreibfehler unterjubeln wollen :P

Ansonsten stimme ich dir natürlich zu: Die Rechtschreibung vieler junger Menschen läßt heute sehr zu wünschen übrig. Scheint fast so, als wollten die gar nicht verstanden werden ... :twisted:

Delete - So 10.11.13 15:08

Perlsau hat folgendes geschrieben :

hathor hat folgendes geschrieben :

Gewöhne Dir mal an, fehlerfrei zu schreiben, sonst wird das mit dem Programmieren NIE etwas!

Sorry!
Hier ist so wenig "Action", dass man kaum noch damit rechnet, Antwort-Kollisionen zu erzeugen.

spoof - So 10.11.13 15:15

Ok, danke für alle Antworten, ich hab es denk ich jetzt verstanden:

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

//button1
procedure TForm1.Button1Click(Sender: TObject);       
begin
messages(5); //springt zu messages mit dem wert 5
end;


//gehört zu button 1
procedure messages(Anzahl: integer);    //Anzahl erhält den Wert 5 und die procedure wird ausgeführt ohne Rückgabewert für die procedure button1click           
  var i: integer;
  begin
    for i := 1 to Anzahl do
      Showmessage(Inttostr(i));
  end;


//button 2
procedure TForm1.Button2Click(Sender: TObject);     
  var i: integer;
  begin
    for i := 1 to messages2(2,5) do      //Das schleifenende ist das Result der Funktion messages2
      Showmessage(Inttostr(i));
end;


 //gehört zu button 2
function messages2(zahl1,zahl2:integer):integer;    //message2 ist ein integer ebenso zahl1 und zahl2, die parameter sind die werte der Übergabe aus der Procedur    
  var i: integer;
  begin
   result:=zahl1+zahl2;               //der wert von messages2
  end;


end.

Hab das mal soweit kommentiert wie ich den Code verstehe und geschrieben hab.

WasWeißDennIch - So 10.11.13 19:57

Naja, nicht so ganz. Reguläre Prozeduren/Funktionen gehören zu gar keiner Klasse, auch nicht zu Button1. Sie sind völlig unabhängig aufrufbar, Beispiel:

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

unit Blabberblubb;

...

implementation

function DasDoppelteVon(Wert: integer): integer;
begin
  Result := Wert * 2;
end;

Die Funktion DasDoppelteVon ist innerhalb der Unit Blabberblubb überall verfügbar und an keine Instanzdaten gebunden. Möchte man sie auch von anderen Units aus aufrufbar machen, muss der Funktionskopf im interface-Teile bekannt gemacht werden:

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

unit Blabberblubb;

interface
...

function DasDoppelteVon(Wert: integer): integer; //Bekanntmachung

implementation

function DasDoppelteVon(Wert: integer): integer;
begin
  Result := Wert * 2;
end;

Im Gegensatz dazu gibt es noch Methoden, die gehören wie schon gesagt zu einer Klasse bzw. einer Instanz davon.

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

type
  TSomeClass = class
  public
    procedure MachWasTolles;
  end;

...

procedure TSomeClass.MachWasTolles;
begin
  (* Ganz toller Code *)
end;

Wie man sieht werden Methoden innerhalb der Klassendeklaration deklariert und in der Implementation (dem eigentlichen Code) muss der Klassenname vorangestellt werden. Das heißt auch, dass man die Methode MachWasTolles nur über eine Instanz von TSomeClass aufrufen kann.

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

procedure TMyForm.Button1Click(Sender: TObject);
var
  SomeClass: TSomeClass;
begin
  (* Erzeugen der Instanz *)
  SomeClass := TSomeClass.Create;
  try
    (* Aufruf der Methode dieser Instanz *)
    SomeClass.MachWasTolles;
  finally
    (* Freigabe der Instanz *)
    SomeClass.Free;
  end;
end;

Entwickler-Ecke.de based on phpBB
Copyright 2002 - 2011 by Tino Teuber, Copyright 2011 - 2025 by Christian Stelzmann Alle Rechte vorbehalten.
Alle Beiträge stammen von dritten Personen und dürfen geltendes Recht nicht verletzen.
Entwickler-Ecke und die zugehörigen Webseiten distanzieren sich ausdrücklich von Fremdinhalten jeglicher Art!