Eigene Prozeduren

[GW1nner]

Hallo,
ne kurze Frage. Wozu erstelle ich eigene Prozeduren?

Ich hab nicht verstanden was mir das bringt... und wann es sinnvoll ist eine selbst zu erstellen.

[implementation]

Zitat:

Zitat von GW1nner

Wozu erstelle ich eigene Prozeduren?

Wenn du irgendeinen Subalgorhythmus immer wieder aufrufen möchtest, der keinen Rückgabewert liefern soll. Sonst nimmst du Funktionen.

Zitat:

Zitat von GW1nner

Ich hab nicht verstanden was mir das bringt... und wann es sinnvoll ist eine selbst zu erstellen.

Immer. Für alles. Was glaubst du wofür es die Prozeduren / Funktionen aus System, SysUtils, crt usw. gibt?

[Jens Hartmann]

Hallo,

eigene Prozeduren erstellst Du z.B. um Aufgaben und Programmteile die Du mehrmals benötigst zusammen zu fassen. Dadurch kannst Du Übersicht in deinen Quellcode bringen und die Funktionen müssen nur noch von den jeweiligen Routinen aufgerufen werden.

Delphi-Quellcode:

procedure TForm1.MeineProcedure;
begin
  IchKannEinenStringKopieren := KopiereString;
end;

//irgendwo im Code
...
MeineProcedure;
..

Das ganze wird natürlich für größere und sinnvolle Codeteile genutzt.

Gruß Jens

[GW1nner]

Ahhh ok danke

Und wie genau funktioniert das dann?
Kann man also Schleifen einmal festlegen und beliebig oft in verschiedenen Prozeduren aufrufen lassen?

Delphi-Quellcode:

procedure TForm1.MeineProcedure;
begin
  zaehler := 0;
  
    REPEAT
      rechnung := 2+2
      ...
      ...
    Until ...
...
...
...

end;

(*Gleiche Schleife beginnt jetzt hier*)
...
MeineProcedure;
..

[implementation]

Delphi-Quellcode:

procedure Prozedur(ParameterListe...);
begin
  while ... do begin
    ...
  end;
end;

procedure TObjekt.Methode(ParameterListe...);
begin
  while ... do begin
    ...
  end;
end;

...

Prozedur(Parameter);
Objektinstanz.Methode(Parameter);
// bzw. bei (statischen) Klassenmethoden
TObjekt.Methode(Parameter);

[Jens Hartmann]

Das hat mit Schleifen nicht unbedingt was zu tun.

Es geht z.B. um Funktionen, die Du ständig durchführen musst. Oder um Funktionen, die Du einfach der Übersichthalber in einen eigene Procedure packen möchtest.

Rein technisch ist es möglich alles einfach im fortlaufend zu schreiben. Allerdings nach ein paar Zeilen Code weißt Du schon nicht mehr was das alles überhaupt macht. Daher erstellt man

Delphi-Quellcode:

function
//oder 
procedure

Und diese je nach Aufgabenstellung auch noch in Units oder Klassen ausgelagert.

Stell Dir das vor wie ein Buch.
Du hast eine Inhaltsverzeichnis, das sind die Funktionen die der User z.B. Ausführen kann. Dann hast Du da units oder Klassen, die du über das Inhaltsverzeichnis ansprechen kannst. (Kapitel wählen). Dann kannst Du natürlich auch direkt Funktionen aufrufen, die sich in der selben Unit oder einer anderen befinden, und diese über die "Seite wählen" ansprechen.

Jedes sauber und gut gegliederte Buch, lässt sich einfach lesen und man findet die gewünschten Information schnell und umgehend.

Gruß Jens

[Wolfgang Mix]

Vielleicht hilft auch dieser alte Pascal-Code, zum Verständnis beizutragen

Delphi-Quellcode:

begin
   Repeat
      Menue;
      ch:=Readkey;
      Case ch of
          '0','p','P': Info;
          '1','q','Q': Quadrat;
          '2','r','R': Rechteck;
          '3','d','D': Dreieck;
          '4','k','K': Kreis;
          '5','e','E': Ellipse;
                 #59 : Hilfe;
      end; { case }

   Until ch = chr(27);    { Escape-Taste }
clrscr
end.

[GW1nner]

Ja ok ich verstehe jetzt was für ein Nutzen eine eigene Prozedur hat.
Es soll übersichtlich sein und Arbeit sparen.

Es soll also letzten Endes nichts neues darstellen?

Man änder nur seine Formulierung sozusagen.
Ähnlich wie noch in der Unterstufe das Zusammenfassen von Termen, es steht das gleiche da nur anders (kompakter).

[Wolfgang Mix]

Naja, so halb. Sollte dir zeigen, daß wann immer du z.B. Rechtecksberechnungen
durchführen willst, du nur deine fertige Prozedur aufrufen mußt.

[scrat1979]

Hier mal ein Link zu einem Grundlagenturorial. Es gibt noch viele im Netz. Damit wird es klarer :)

Nehmen wir mal an, Du hast einen code z.b. um eine Anzeige zu aktualisieren, nachdem beispielsweis neue Daten irgendwo eingetragen wurden (z.B. Tabelle) oder gelöscht wurde. Dann müsstest du überall in Deinem Programmcode, in welchem die Anzeige aktualisiert werden muss, den gleichen code benutzen. Diesen redundanten Code kannst Du in einer Prozedur auslagern und statt den z.B. 20 Zeilen Code nur die Prozedur mit einem Befehl starten. Hast Du nun z.B. 10 Stellen in Deinem Code, wären das 10 Zeilen statt ca. 200 Zeilen.

Außerdem: Solltest Du den Code - aus welchen Gründen auch immer - anpassen müssen, dann musst du diesen an ALLEN Stellen in Deinem Code ändern (hier kann man auch mal was vergessen :) ). Bei einer Prozedur wird der code 1x geändert und alle Aufrufe benutzen nun den aktuellen Code.

Funktionen geben Dir einen Wert zurück ("ähnlich einer Variablen"). Beispiel:

Delphi-Quellcode:

function IchZaehleZweiZahlenZusammen(zahl1,zahl2:integer) : integer;
begin
 result := zahl1 + zahl2;
end;

Beispielaufruf:

Delphi-Quellcode:

var a : integer; 
[...]
 ShowMessage('7 + 19 = ' + IntToStr(IchZaehleZweiZahlenZusammen(7, 19)));
 // oder...
 a := IchZaehleZweiZahlenZusammen(30, 78); // in Variable a ist nun der Wert 108 gespeichert
 [...]

Zwar etwas sinnfrei, das Prinzip dürfte es aber erklären.


Aber wie gesagt, schau die Tutorials an, die geben Dir Aufschluss darüber!

SCRaT