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

[malo]

hi!

Ich dachte mir, dass ich für meine Homepage ein paar Tutorials schreiben könnte. Und logischerweise ist das einfachste dann ein Einsteigertutorial. Jetzt hatte ich ein Einsteigertutorial angefangen, wo ich Delphi (Pascal) auf Grundlage von nonVCL-Programmen schildere. Allerdings hab ich darüber auch eine zeitlang nachgedacht, und bin zu dem Entschluss gekommen, dass ich das Tutorial ja gar nicht wirkich beenden kann, weil ich von WinAPI-Programmierung kaum Ahnung hab, und das ja eigentlich der Hauptbestandteil von nonVCL-Programmen ist (wenn man nicht alles in der Konsole machen will). Außerdem schreibt Luckie in seinem WinAPI-Tutorial:

Zitat:

Zitat von Luckies Tutorial

Bevor Sie jedoch beginnen nonVCL-Programme zu schreiben, sollten Sie sich mit den Grundlagen der Programmierung in
PASCAL respektive ObjectPascal (Delphi) auskennen. Es macht nicht viel Sinn, völlig ohne Vorkenntnisse in diese Materie
einsteigen zu wollen. Frust dürfte wohl die Folge sein.

Deshalb hab ich einfach mal angefangen, ein VCL-Tutorial zu schreiben (was jedoch noch ziemlich am Anfang ist). Ich musste mir dafür jedoch Morddrohungen von Robert_G anhören, weshalb ich jetzt diese Frage hier stelle:
Sollte man lieber ein Tutorial für VCL oder lieber ohne Nutzung VCL schreiben? Die Vorteile von nonVCL liegen zwar klar auf der Hand, aber gerade für Anfänger muss es ja die Hölle sein, wenn man nicht einfach auf das "Klickie-Buntie"-Feature zurückgreifen kann. 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.


PS: Ich will jetzt keine Kommentare zu dem Thema, ob sich Einsteigertutorials lohnen o.Ä.. Ich will ein Tutorial schreiben, weil es mir Spaß macht, wenn ich anderen helfen kann. Außerdem will ich auch ein wenig eigenes Material für meine Homepage haben *g*

[MagicAndre1981]

Einsteigertutorials immer als Konsolenanwendungen um die Eigenschaften von Delphi kennen zu lernen, wie Variablen, Funktionen, Prozeduren, Schleifen etc.

Später dann wohl VCL, wenn es um GUIs gehen soll.

André

[SirThornberry]

Wie du selbst schon geschrieben hast sollten zuerst die Grundlagen vermittelt werden und das nicht im Sinne von VCL oder nonVCL sondern:
- Was sind Variablen
- Wozu werden sie Benötigt
- Wie weißt man Variablen einen Wert zu
- Welche Datentypen gibt es (integer, word, extended, double...) und wann wird welcher verwendet
- später dann eventuell noch pointer grundlagen, was bedeuten @, ^Type, Variable^

somit werden später auch fragen vermieden wie "warum geht inttostr(5.137) nicht"

nach diesen Grundlagen sollte man dann noch darauf eingehen was objecte sind und wann es nötig ist ein Object zu instanzieren (Object := TObject.Create) und wann nicht.

Am besten du schaust mal auf www.delphi-source.de nach was es so für grundlagen-tutorials gibt.
Wie du jetzt bestimmt mitbekommen hast sind alle punkte die ich aufgeführt habe unabhängig von VCL oder nonVCL und so gibt es auch noch jede menge andere Grundlagen wo VCL oder nonVCL noch keine Rolle spielt, denn Sinn ist es ersteinmal den Sparchkonstrukt zu verstehen. (als ich von basic zu Delphi gewechselt bin hab ich bestimmt 1 Tag gebraucht um zu wissen das eine zuweisung ein ":=" erfordert und ein einfaches "=" nicht reicht)

[tommie-lie]

Zitat:

Zitat von malo

weil ich von WinAPI-Programmierung kaum Ahnung hab

Ja, das ist immer die beste Vorraussetzung, um ein Tutorial zu schreiben...

Zitat:

Sollte man lieber ein Tutorial für VCL oder lieber ohne Nutzung VCL schreiben? Die Vorteile von nonVCL liegen zwar klar auf der Hand, aber gerade für Anfänger muss es ja die Hölle sein, wenn man nicht einfach auf das "Klickie-Buntie"-Feature zurückgreifen kann. 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.

Du hast doch die Frage schon selbst beantwortet. Für einen Anfänger ist nonVCL-Programmierung (mit grafischer Benutzeroberfläche :zwinker:) viel zu umständlich. Oft werden auf Pointer und sonstige Dinge zurückgegriffen, mit denen ein Anfänger nichts anfangen kann. Der Umfang der nonVCL-Programmierung ist viel zu groß. Außerdem müsstest du ja auch noch in die Eigenheiten von Pascal-Strings und den Unterschied zu C-Strings eingehen.
.NET ist für einen Anfänger genauso überladen. Nicht wissen, wie man einen Algorithmus umsetzt und was eine Schleife ist, aber mit Klassen und Objekten rumjonglieren?
Wenn du nicht mit Konsolenanwendungen anfangen willst, solltest du mit VCL-Programmen anfangen. Der Anfänger soll schrittweise Programmieren lernen und nicht von Anfang an alle Feinheiten moderner Hochsprachen um die Ohren gehauen kriegen.

[malo]

Hi!

Danke für die Antworten.

@MagicAndre1981: Sowas in der Art hatte ich ja eigentlich bei meinem nonVCL-Tutorial vor, aber den Sprung zur VCL finde ich nicht so schön, wenn er so abrubt ist ;)

@SirT: Ich hatte ja aber zusätzlich vor, zu jeder Erklärung einen kurzen Beispielsource zu posten und diesen dann genauer zu erklären. Und da macht es, meiner Meinung nach, schon einen Unterschied, ob man alles anhand von VCL-Anwendungen oder nonVCL-Anwendungen beschreibt ;)

Ganz besonders auch Text Ein- und Ausgaben ;)

@tommie-lie: Die Gröbsten Grundlagen der WinAPI hab ich ja so ungefähr drauf, wie zum Beispiel eine Message abschicken oder empfangen. Aber das wars eigentlich schon so ziemlich... :?

Die Idee mit dem VCL-Tutorial hatte ich ja, wie gesagt, schon. Aber dazu musste ich mir Morddrohungen ( :mrgreen: ) anhören und schiefe Blicke zuwerfen lassen... Und irgendwie hab ich dann auch die Angst, dass aus meinen Tutorial-Lesern dann später einmal "Klickie-Buntie-Programmierer" werden... :?

[Robert_G]

Zitat:

Zitat von MagicAndre1981

Einsteigertutorials immer als Konsolenanwendungen um die Eigenschaften von Delphi kennen zu lernen, wie Variablen, Funktionen, Prozeduren, Schleifen etc.

Später dann wohl VCL, wenn es um GUIs gehen soll.

Genauz so. Einsteiger haben im visuellen designer nichts zu suchen... Jedenfalls nicht wenn sie es in einer halbwegs akzeptierbaren Zeit lernen wollen. ;)

Genau DAS meinte ich gestern Abend. ;)

[gordon freeman]

Wir arbeiten in der Schule mit Konsolenanwendungen, um die Grundlagen zu erlernen. DAs ist IMHO absolut vernünftig und bringt auch einen relativ hohen Lernerfolg.

[stoxx]

Zitat:

Genauz so. Einsteiger haben im visuellen designer nichts zu suchen

und genau das ist falsch ! Ich würde Dir raten, sofort mit VCL anzufangen.
Es ist zwar toll zu wissen, wie eine Konsole funktioniert, aber das ist nicht der natürliche Lauf der Geschichte.
In keiner Wissenschaft, die schon längerer Zeit besteht, haben Menschen eine Chance alles zu wissen.
Man stelle sich einen Apotheker vor, der wie früher all seine Medikamente selber herstellen müsste.
UNMÖGLICH !
Pass auf dass Dir die Zeit mit Konsolenanwendungen nicht davon rennt. Du hast nicht ewig Zeit, glaub mir ;-)

[malo]

Zitat:

Zitat von Robert_G

Zitat:

Zitat von MagicAndre1981

Einsteigertutorials immer als Konsolenanwendungen um die Eigenschaften von Delphi kennen zu lernen, wie Variablen, Funktionen, Prozeduren, Schleifen etc.

Später dann wohl VCL, wenn es um GUIs gehen soll.

Genauz so. Einsteiger haben im visuellen designer nichts zu suchen... Jedenfalls nicht wenn sie es in einer halbwegs akzeptierbaren Zeit lernen wollen. ;)

Genau DAS meinte ich gestern Abend. ;)

Hm... echt? :mrgreen:

Naja, dann werd ich wohl doch wieder mit dem nonVCL-Tutorial weitermachen... danke für die Antworten!


Wenn jemand eine der Aussagen wiederlegen will, bin ich jedoch gerne noch bereit, seine Meinung zu hören :)

//edit: :oops: Hab wohl etwas lange gewartet, vor dem Abschicken... ein beitrag verpasst.

[Robert_G]

Zitat:

Zitat von stoxx

Zitat:

Genauz so. Einsteiger haben im visuellen designer nichts zu suchen

und genau das ist falsch ! Ich würde Dir raten, sofort mit VCL anzufangen.
Es ist zwar toll zu wissen, wie eine Konsole funktioniert, aber das ist nicht der natürliche Lauf der Geschichte.

Das tolle an einer Konsolen app ist, dass man da fast gar nix wissen muss.
Alles läuft genauso wie man es erwartet und man sieht alles was da passiert. Es gibt keine 1,5MB große VCL.bpl, die einem im Hintergrund den Hintern abwischt.

Denn DAS verunsichert doch einen NewBie. Warum soll er denn auch einen Button auf ein Form ziehen sollen.
Der denkt sich doch nur... Krass! Was ist denn ein Form? Was ist ein Event? Und warum steht da oben class.?
Bis er DAS kapiert hat. Ableitung, Felder, Propeties, Funktionszeiger (also Events) vergehen sicher Jahre. (Wenn er bei jeder Gelegenheit mit Dingen erschlagen wird, die ihm suggerieren, dass er keine Ahnung hat)

Zitat:

Zitat von stoxx

In keiner Wissenschaft, die schon längerer Zeit besteht, haben Menschen eine Chance alles zu wissen.
Man stelle sich einen Apotheker vor, der wie früher all seine Medikamente selber herstellen müsste.
UNMÖGLICH !

Und was wenn er am ersten Tag vor eine Maschine gestellt wird, die das ALLES kann? Der arme kleine Apotheker bekommt vielleicht 3 Knöpfe erklärt, mit denen er etwas Milchzucker und MDMA verrühren kann. Aber du kannst dir sicher sein, dass ihn die anderen 5.000 Knöpfe verunsichern werden und somit seine Lernkurve abstürzen lassen.

Zitat:

Zitat von stoxx

Pass auf dass Dir die Zeit mit Konsolenanwendungen nicht davon rennt. Du hast nicht ewig Zeit, glaub mir ;-)

Die ersten Schritte ohne VCL wären nötig um ihn in kürzerer Zeit in die Lage zu versetzen eine vorzeigbare VCL Lösung zu produzieren. (Also nicht eine in der alles strunzdumm nur in irgendwelchen OnClicks & Co steht. ;) )

[MathiasSimmack]

Zitat:

Zitat von malo

Naja, dann werd ich wohl doch wieder mit dem nonVCL-Tutorial weitermachen... danke für die Antworten!

Wo ist der Unterschied zwischen dem von dir geplanten Tutorial und denen von ... äh ... von Luckie? Gibt es Dinge, die du vermisst? Dinge, die du nicht verstehst? Dinge, die du anders erklärt hättest? Ich, in meiner Eigenschaft als Butler von Herrn Puff :mrgreen: und als geheimer Autor der Tutorials, bin immer gern bereit, mir Verbesserungsvorschläge anzuhören.

[malo]

Zitat:

Zitat von MathiasSimmack

Zitat:

Zitat von malo

Naja, dann werd ich wohl doch wieder mit dem nonVCL-Tutorial weitermachen... danke für die Antworten!

Wo ist der Unterschied zwischen dem von dir geplanten Tutorial und denen von ... äh ... von Luckie? Gibt es Dinge, die du vermisst? Dinge, die du nicht verstehst? Dinge, die du anders erklärt hättest? Ich, in meiner Eigenschaft als Butler von Herrn Puff :mrgreen: und als geheimer Autor der Tutorials, bin immer gern bereit, mir Verbesserungsvorschläge anzuhören.

Nein, so ist es nicht. Nur Luckie geht das alles von einer anderen Seite an. Ich will niemandem etwas von der WindowsAPI beibringen, von der ich selbst kaum etwas weiß. Ich will ihnen die Programmiergrundlagen klar und verständlich beibringen. Mit "nonVCL-Tutorial" meine ich ein Tutorial, das nicht auf die VCL aufbaut. In meinem Falle eher ein Konsolenprogramm-Tutorial ;)

Ganz nebenbei finde ich, dass es sich gar nicht wirklich lohnt, die WindowsAPI zu lernen. Besonders für mich nicht. Wenn ich mal in einen Beruf gehe und wirklich professionell programmieren werde, wird Longhorn wohl schon ein Auslaufmodell sein, und es werden Leute ausgelacht, die wirklich noch professionell mit der WinAPI arbeiten :mrgreen:

[Hansa]

In Zeiten, wo massenweise WinAPI Funktionen ersetzt werden, macht es absolut keinen Sinn, nach dem Motto "jetzt erst Recht" noch damit anzufangen. 8) Zumal es noch schlimmer ist, als eine Konsolenanwendung zu schreiben. Die WinAPI Geschichten wird man in absehbarer Zeit komplett aus seinem Wortschatz streichen können.

Ein Anfänger-Tutorial jetzt aber mit einer Konsolenanwendung beginnen zu wollen ? Weiß net. Schätze mal, daß die heutzutage verwöhnten und faulen :mrgreen: Anfänger dann zu schnell die Lust verlieren. Ich würde sagen es ist für einen Anfänger intuitiver mit VCL, weil da was zu sehen ist und nicht nur das Ergebnis. Eventuell 1-2 kurze Konsolen-Beispiele.

Zitat:

Zitat von Malo

Ich will niemandem etwas von der WindowsAPI beibringen, von der ich selbst kaum etwas weiß

Dann hast Du ja zumindest die Haupt-Richtlinie für Tutorial-Schreiber schon gelernt. :mrgreen: Allerdings verstehe ich nun die Frage an sich nicht mehr. :stupid:

[Jasocul]

Für ein Anfänger-Tutorial würde ich durchaus die VCL mit benutzen.
Auch einem Anfänger kann man klar machen, dass einige Automatismen erst später erklärt werden können, wenn andere Grundlagen vorhanden sind.
Schicke Konsolenanwendungen gibts natürlich auch. Aber wer will einem Anfänger ernsthaft die GotoXY-Anweisung erklären, wenn sowas in 99,999% der Fälle überhaupt nicht mehr benötigt wird (Alle die sich für Programmierer halten und den Befehl nicht kennen, bitte melden :lol: ).
Heutige Anwendungen bestehen überwiegend aus Dialog-Anwendungen!
Warum soll man Interaktionen nicht mit ganz einfachen VCL-Komponenten (TEdit und TButton genügen normalerweise) dargestellt werden.

WinAPI: Die muss man nicht kennen, um ein gutes Tutorial zu schreiben!
Ich muss aich nicht verstehen, wie ein Motor funtkioniert, um Auto zu fahren.

[Robert_G]

Könntest du mir mal erklären, wie du auf den Blödsinn kommst?

Zitat:

Zitat von Jasocul

Schicke Konsolenanwendungen gibts natürlich auch. Aber wer will einem Anfänger ernsthaft die GotoXY-Anweisung erklären...

Und nunja... ein weiteres hirnloses VCL based Tutorial braucht doch keine Sau. DSDT ist voll mit dem Krempel, genau wie der Rest des Internets.
Nachdem jemand kapiert hat wie er einen Button auf ein Form ziehen kann wird er wohl nicht mehr aufpassen um zu kapieren wass ein class macht.
Viele Delphianer sind einfach zu unfähig um objektorientiert zu programmieren, rate mal woher das kommt?

Warum sollte malo auch nur eine Minute opfern um noch mehr von diesen "Programmierern" zu züchten, die alles in OnClicks stehen haben? Solche Typen sind doch bei VB sowieso besser aufgehoben. Damit lassen sich solche Kindereien nämlich schneller und einfacher bauen.

[MathiasSimmack]

Zitat:

Zitat von Hansa

Die WinAPI Geschichten wird man in absehbarer Zeit komplett aus seinem Wortschatz streichen können.

Stimmt, weil es ja auch eigentlich das API heißt. :stupid: Meine kurze Geschichte:

• KC-Basic (KC-85)
• GW-Basic (MS DOS 3.x, 4.x)
• Turbo/BorlandPASCAL
• Delphi
• CSharp

Ich habe auch mit der VCL angefangen, und ich habe meine Kenntnisse nicht bereut, als ich meine ersten Versuche im nonVCL-Bereich unternommen habe. Da mich "Herr Puff" ja als Depp bezeichnete, sage ich es noch mal ganz deutlich: Das Zitat in malos erstem Beitrag ist aus meiner Feder. Herr Puff würde solche schönen Worte nie benutzen. :mrgreen:

Nein, aber ernsthaft: In Einzelfällen halte ich nonVCL für vertretbar. Immer noch. Und wenn man weiß wie es geht, bzw. wo es steht (8)), dann schadet das auch nicht.

[Jasocul]

Ein echte Robert_G-Antwort.

Zitat:

Zitat von Robert_G

Könntest du mir mal erklären, wie du auf den Blödsinn kommst?

Zitat:

Zitat von Jasocul

Schicke Konsolenanwendungen gibts natürlich auch. Aber wer will einem Anfänger ernsthaft die GotoXY-Anweisung erklären...

Wieso, kennst du den nicht?

Zitat:

Zitat von Robert_G

Und nunja... ein weiteres hirnloses VCL based Tutorial braucht doch keine Sau. DSDT ist voll mit dem Krempel, genau wie der Rest des Internets.

Das hat auch keiner gefragt oder behauptet. Wenns aber hilft zu lernen, wie man ein Tutoiral schreibt, ist das völlig OK.

Zitat:

Zitat von Robert_G

Nachdem jemand kapiert hat wie er einen Button auf ein Form ziehen kann wird er wohl nicht mehr aufpassen um zu kapieren wass ein class macht.
Viele Delphianer sind einfach zu unfähig um objektorientiert zu programmieren, rate mal woher das kommt?

Weil die meisten Tutorials nach den grundlegenden Dingen vergessen auf die Hintergründe einzugehen?

Zitat:

Zitat von Robert_G

Warum sollte malo auch nur eine Minute opfern um noch mehr von diesen "Programmierern" zu züchten, die alles in OnClicks stehen haben? Solche Typen sind doch bei VB sowieso besser aufgehoben. Damit lassen sich solche Kindereien nämlich schneller und einfacher bauen.

Na dann hast du ja einen sicheren Job.

Kannst du jetzt wieder sachlich argumentieren?

Programmieren besteht nicht aus dem Zusammenklicken von schicken Fenstern. Die dahinterliegende Funktionalität macht ein Programm aus.

[tommie-lie]

Zitat:

Zitat von Jasocul

Ein echte Robert_G-Antwort.

:mrgreen:

Zitat:

Zitat von Jasocul

WinAPI: Die muss man nicht kennen, um ein gutes Tutorial zu schreiben!
Ich muss aich nicht verstehen, wie ein Motor funtkioniert, um Auto zu fahren.

Aber du solltest wissen, wie man Auto fährt, wenn du anderen Autofahren beibringen willst. malo sprach oben von einem nonVCL-Tutorial, und darunter verstehen die meisten (lies: alle, die oben was gepostet haben ;-)) Programme, die grafisch sind aber nicht die VCL nutzen, also auf die Win32-API zurückgreifen. Wenn er da keine Ahnung hat und ein Tutorial drüber schreiben will, wäre das, als ob ein Taubstummer dir Musikunterricht geben will ;-)

Zitat:

Zitat von Robert_G

Nachdem jemand kapiert hat wie er einen Button auf ein Form ziehen kann wird er wohl nicht mehr aufpassen um zu kapieren wass ein class macht.
Viele Delphianer sind einfach zu unfähig um objektorientiert zu programmieren, rate mal woher das kommt?

Rate mal, wie ich damals vor drei Jahren (Oder sind's schon 4? :gruebel: Ich werd' alt :shock:) mit Delphi angefangen habe? Da war ich froh, daß es die VCL gab, dennoch habe ich kurze Zeit später begriffen, was ich mit Objektorientierung so alles anstellen kann :zwinker:

Zitat:

Zitat von Robert_G

Warum sollte malo auch nur eine Minute opfern um noch mehr von diesen "Programmierern" zu züchten, die alles in OnClicks stehen haben? Solche Typen sind doch bei VB sowieso besser aufgehoben. Damit lassen sich solche Kindereien nämlich schneller und einfacher bauen.

Du weißt aber, daß einige Firmen Delphi und den BCB gerade wegen der VCL einsetzen, weil sie schnell Funktionalität bauen können und sich nicht stundenlang mit der GUI und Serveranbindung rumschlagen wollen, wenn sie mal ein kleines Testtool für den Datenbank-Server im Keller schreiben wollen?

[Jasocul]

Zitat:

Zitat von tommie-lie

Zitat:

Zitat von Jasocul

WinAPI: Die muss man nicht kennen, um ein gutes Tutorial zu schreiben!
Ich muss aich nicht verstehen, wie ein Motor funtkioniert, um Auto zu fahren.

Aber du solltest wissen, wie man Auto fährt, wenn du anderen Autofahren beibringen willst. malo sprach oben von einem nonVCL-Tutorial, und darunter verstehen die meisten (lies: alle, die oben was gepostet haben ;-)) Programme, die grafisch sind aber nicht die VCL nutzen, also auf die Win32-API zurückgreifen. Wenn er da keine Ahnung hat und ein Tutorial drüber schreiben will, wäre das, als ob ein Taubstummer dir Musikunterricht geben will ;-)

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.

[Speedmaster]

Ich schlage immer nur nonVCL vor, ich habe zwar mit der VCL gelernt(Von Selber), habe aber dafür länger gebraucht zu Kapieren woraus eine Form z.b. besteht!

Deshalb nonVCL und da z.b. einen kleinen Taschenrechner!

[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 )!