Womit sollte ein Delphi-Anfänger beginnen? VCL oder nonVCL?

[Jasocul]

Die Frage war:

Zitat:

Womit sollte ein Delphi-Anfänger beginnen? VCL oder nonVCL?

Wenn nonVCL verwendet wird (Beispiel Taschenrechner), verkaspert der Anfänger sich doch hoffnungslos in der Darstellung der Objekte in einem Fenster. Ich bezweifle ganz stark, dass OOP gemacht werden soll, bevor nicht mal die Basis da ist (Variablen, Bedingungen, Schleifen,...). Habe kuürzlich ein Buch gelesen (C#), das genauso arbeitet. Furchtbar! Listings, die sich erstmal damit beschäftigen müssen, wie man die Oberflächen generiert. Nein Danke.

Entweder Konsole oder VCL. Was ich bevorzuge, habe ich schon geschrieben. nonVCL aber auf gar keinen Fall.

[Speedmaster]

Zitat:

Zitat von Jasocul

Die Frage war:

Zitat:

Womit sollte ein Delphi-Anfänger beginnen? VCL oder nonVCL?

Wenn nonVCL verwendet wird (Beispiel Taschenrechner), verkaspert der Anfänger sich doch hoffnungslos in der Darstellung der Objekte in einem Fenster. Ich bezweifle ganz stark, dass OOP gemacht werden soll, bevor nicht mal die Basis da ist (Variablen, Bedingungen, Schleifen,...).

Entweder Konsole oder VCL. Was ich bevorzuge, habe ich schon geschrieben. nonVCL aber auf gar keinen Fall.

Consolenanwendungen gehören zu nonVCL( Man kann natürlich auch VCL mit Console machen ), aber ich meinte Eigentlich den Taschenrechner als Consolenanwendung!

[Robert_G]

Zitat:

Zitat von Jasocul

Stimmt schon. Aber als Fahrlehrer muss ich auch keinen Motor auseinandernehmen.

nonVCL ist sicher nicht der richtige Weg! Denn dafür muss man den Motor (WinAPI) kennen.

Meine Empfehlung bleibt VCL. Entscheiden darf malo das aber alleine.

Woher habt ihr denn die WinAPI? :gruebel:
Malo meinte mit nonVCL eine simple Console App OHNE Fenster und OHNE VCL.
Die WinAPI habt ihr rausgelesene, denn malo hat explizit darauf hingewiesen, dass er KEIN nonVCL tutorial machen will.
Einem Anfänger die grausigen Abgründe der WinAPI zu stoßen wäre entweder dumm geplant oder hundsgemein. ;)

Ich habe auch mit KEINEM Wörtlein WinAPI basiertes Fenstergefriemel erwähnt!

Ich bin halt nur der Meinung, dass man schneller lernen kann, wenn man das zu Lernende absolut überschauen kann.

Will Mr NewBie eine Klasse mit 2 Properties instanzieren die ene Eigenschaft besetzen und die andere in die ausgeben -> In einer Konsolen App hat er nur seinen Code, plus WriteLn und ReadLn.
Da passiert nix großartiges, dass abstrakt für ihn wäre.

[tommie-lie]

Zitat:

Zitat von Jasocul

nonVCL ist sicher nicht der richtige Weg! Denn dafür muss man den Motor (WinAPI) kennen.

Zitat:

Zitat von Jasocul

Wenn nonVCL verwendet wird (Beispiel Taschenrechner), verkaspert der Anfänger sich doch hoffnungslos in der Darstellung der Objekte in einem Fenster.

Du hast immer noch nicht verstanden, daß malo mit nonVCL nicht das meinte, was ich und andere (offensichtlich auch du) unter nonVCL-Programmierung verstehen, sondern Konsolenanwendungen einbezieht, oder?

Um wenigstens ein bisschen Programmierkomfort zu haben und als Einstieg in die Objektorientierung bleibt ja immer noch die CLX, die kann man schließlich auch in Konsolenanwendungen benutzen.

[Jasocul]

Grundsätzlich habt ihr Recht (Console ist auch nonVCL).
Die WinAPI kam durch diesen Satz von malo in die Diskussion:

Zitat:

Außerdem müsste man für nonVCL auch in die WinAPI-Materie eingehen, über dessen Vorzüge man seit dem Erscheinen von D8 mehr denn je streiten kann.

Sorry für das Missverständnis. Hätte mir eigentlich klar sein sollen.

[Speedmaster]

Ich hatte mal was für einen Kollegen geschrieben das sah so aus:

dpr Datei:

Delphi-Quellcode:

program MeineExe;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  MeineUnit in 'MeineUnit.pas';

var
  MeineKlasse: TMeineKlasse;
  // Gibt Klassentyp an
  Finished:    Boolean;
  // Deklariert Variable(Muss nicht erzeugt werden)
  Userinp:    String;
  // Usereingabe
  Zahlen: record    // Eine zusammenfassung von 2 Variablen
    Zahl1: Integer;
    Zahl2: Integer;
  end;

begin
  WriteLN('***********************************');
  WriteLN('* Hallo zu meinem ersten Programm *');
  WriteLN('*        Mathematik pur           *');
  WriteLN('***********************************');
  // Textausgabe
  Sleep(2000);  // 2sec warten

  MeineKlasse := TMeineKlasse.create;
  // Erzeugt die Klasse
  MeineKlasse.ProduktProc(5,7);
  // Ruft eine Procedure(Aufgabe) auf
  WriteLn('Ergebniss aus 5 * 7: ' + MeineKlasse.MeinString);
  // Textausgabe
  Sleep(1000);
  // 1sec Warten
  WriteLn('Ergebniss aus 7 * 9: ' + MeineKlasse.Produktfunc(7,9));
  (* Anmerkung: Hier wurde eine Funktion aufgerufen die einen Rückhabetyp besitzt
     --> Textausgabe *)
  Sleep(1000);
  // Warten


  while Finished = False do begin
    WriteLn('-----------------------------------');
    // Solange Finished nicht True ist mache immer dasselbe
    write('Zahl 1 angeben: ');
    // User Zahl eingeben lassen
    ReadLn(Zahlen.Zahl1);
    // Zahl auslesen
    write('Zahl 2 angeben: ');
    // Zweite Zahl eingeben
    ReadLn(Zahlen.Zahl2);
    // Zweite Zahl auslesen
    WriteLn('Ergebniss aus ' + Zahlen.Zahl1.ToString + ' * '
                + Zahlen.Zahl2.ToString + ': '
                + MeineKlasse.Produktfunc(Zahlen.Zahl1,Zahlen.Zahl2));
    // Ergebniss ausgeben, dabei kann Quelltext auch über mehrere Zeilen gehen
    // für die Übersichtlichkeit
    Sleep(500);
    // Warten
    WriteLn('-----------------------------------');
    Write('Programm beenden(Y/N)?');
    // Fragen on Programm beendet werden soll
    ReadLn(Userinp);
    // Eingabe einlesen
    if Userinp = 'Y' then
      Finished := True
    else
      if Userinp = 'N' then
        Finished := False;
    // Verarbeitung
  end;

  { TODO -oUser -cConsole Main : Hier Code einfügen }
end.

MeineUnit.pas

Delphi-Quellcode:

interface

uses
  SysUtils;

type
  TMeineKlasse = class   // Deklariert eine Klasse mit dem Namen TMeineKlasse
    private

    protected

    public
      MeinString: String;
      // Deklariert die Variable MeinString vom Typ String
      MeineZahl: integer;
      // Deklariert die Variable MeineZahl vom Typ Integer
      procedure ProduktProc(ErsteZahl, ZweiteZahl: integer);
      // Deklariert eine Procedure mit dem Namen ProduktProc und 2 Parametern
      function Produktfunc(ErsteZahl, ZweiteZahl: integer): String;
      // Deklariert eine Funktion mit dem Namen ProduktProc und 2 Parametern und
      // dem Rückgabewert vom Typ String
    published

    end;


implementation

procedure TMeineKlasse.ProduktProc(ErsteZahl, ZweiteZahl: integer);
var
  Produkt: integer;  // Deklariert eine Variable mit dem Namen Produkt
begin
  Produkt := (ErsteZahl * ZweiteZahl);
  // Weisst der Variable Produkt das Produkt der Variablen ErsteZahl und ZweiteZahl zu
  self.MeinString := Produkt.ToString;
  // Weisst der Variablen MeinString den String der Zahl der Variable Produkt zu
end;

function TMeineKlasse.Produktfunc(ErsteZahl, ZweiteZahl: integer): String;
var
  Produkt: integer;  // Deklariert eine Variable mit dem Namen Produkt
begin
  Produkt := (ErsteZahl * ZweiteZahl);
  // Weisst der Variable Produkt das Produkt der Variablen ErsteZahl und ZweiteZahl zu
  Result := Produkt.ToString;
  // Gibt den String der Zahl der Variable Produkt zurück

  // Result ist ein Reserviertes Wort für jede Funktion und ist die Rückgabe
end;

end.

Würde es jetzt anderst schreiben, ist aber durchaus gut zu lernen!

Ach ja: Man kann in jeder Anwendung eine Console benutzen( Ich mache das z.b. zu Debugzwecken )!