[Anfänger] Versuche mich gerade an TYPE Deklarierung

[CaptainJens]

Hallo Leute,

ich bin gerade dabei mich mit Lazarus für die Uni auseinander zu setzen. Lazarus sind auch meine ersten Schritte auf dem Gebiet der Programmierung. Ich hangel mich durch dieses Tutorial. Ich wollte ein Programm schreiben, dass zwei Zahlen miteinander addiert, solange bis man zur Frage, ob man es Beenden soll mit "Y" antwortet.

Code: Alles auswählen

program Addition;
USES Crt;
TYPE Wertebereich = 0..50;
YN = (Y, N);
VAR Summand1, Summand2: Wertebereich;
    Beenden: YN;
    Summe: integer;
 
 
begin
  ClrScr;
 
Repeat
  WriteLn ('Mit diesem Programm werden 2 Zahlen addiert, von 1 bis 50');
  Write ('Bitte geben Sie die erste Zahl ein: ');
  ReadLn (Summand1);
  Write ('Bitte geben Sie die zweite Zahl ein: ');
  ReadLn (Summand2);
Summe := Summand1 + Summand2;
Write ('Das Ergebnis ist: ');
WriteLn (Summe);
WriteLn ('Beenden? (Y/N)');
ReadLn (Beenden);
Until (Beenden = 'Y');
 
End.

Ich kriege den Fehler "Addition.lpr(24,16) Error: Operator is not overloaded: "YN" = "Char"" und die Zeile bei "Until (Beenden = 'Y')" wird mir markiert. Ich verstehe einfach nicht was ich falsch gemacht habe.

Liebe Grüße

[compmgmt]

Beenden ist ein Aufzählungstyp, du versuchst aber einen String zu übergeben. Das sind zwei unterschiedliche Typen. ReadLn() übergibt ein String. Was du brauchst ist ReadKey aus der unit crt.

[mse]

Etwas vereinfacht: 'Y' ist eine Stringkonstante und kann nur mit strings (=Zeichenkette) verglichen werden.

Code: Alles auswählen

 
type
 YN = (Y, N);
var
 Beenden: YN;
 

definiert einen Aufzählungstyp welcher intern als Ganzzahl dargestellt wird, wobei 0 der Bezeichnung Y entspricht und 1 -> N. Darum kann der Vergleich bei

Code: Alles auswählen

 
 Until (Beenden = 'Y');
 

nicht kompiliert werden, da Beenden vom Typ YN->Ganzzahl ist und 'Y' vom Typ string.
Also:

Code: Alles auswählen

 
 Until (Beenden = Y);
 

Hier wird intern Ganzzahl mit Ganzzahlkonstante verglichen.
Wird weder Y oder y noch N oder n eingegeben bricht das Programm mit einer Fehlermeldung ab. Alternative:

Code: Alles auswählen

 
VAR 
 Summand1, Summand2: Wertebereich;
 Beenden: string;
 Summe: integer;
[...]
 ReadLn(Beenden);
 Until (Beenden = 'Y');
 

Hier wird string mit Stringkonstante verglichen.

[Mathias]

Wen man Pascal-Konform einen Typ deklariert, schreibt man ein T davor, zB. so:

Code: Alles auswählen

type
 TYN = (Y, N);
var
 Beenden: TYN;

Dies macht das Ganze übersichtlicher.

[Warf]

Wirf dieses Tutorial mal bitte ganz schnell weg. Wenn es dir keine Konventionen wie Ungarische Notation, die Pascal interne Namenkonvention (T für Typ, P für Pointer, E für Exception, I für Interface) und eine vernünftige (englische) Benennungskonvention beibringt ist es kompletter Müll. Grade wenn du im Team arbeitest und man sich nicht an diese Konventionen hält ist Chaos vorprogrammiert. Außerdem ist die letzte Aktualisierung 2009 gewesen, seit dem hat sich zwischen Version 2.2 und 3.0 einiges getan. (Noch dazu finde ich die Caps Schreibweise für Schlüsselwörter grauenhaft, das ist aber Geschmacksache).

Im FreePascal wiki gibt es ein Tutorial: Link (Englisch)
und auch wenn Eigenlob stinkt, ich schreibe aktuell an einem FreePascal Tutorial: Link (Deutsch)
Bin allerdings nur mit klassischem Pascal bisher fertig, OOP fehlt bisher komplett, aber die Grundlagen sind alle drin. Hatte bisher auch noch keine Lust einige Rechtschreibfehler zu korrigieren.
Das Tutorial habe ich für ein anderes geschrieben, daher findest du die neueren Kapitel dort (Link) da ich dafür noch keine Lust hatte diese in HTML zu übersetzen.

[Mathias]

Wirf dieses Tutorial mal bitte ganz schnell weg. Wenn es dir keine Konventionen wie Ungarische Notation, die Pascal interne Namenkonvention (T für Typ, P für Pointer, E für Exception, I für Interface) und eine vernünftige (englische) Benennungskonvention beibringt ist es kompletter Müll.

Dies ist recht Schade, da gibt man sich Mühe ein Tutorial zu schreiben und bringt dem Anwender falsches bei.

[wp_xyz]

Wirf dieses Tutorial mal bitte ganz schnell weg. Wenn es dir keine Konventionen wie Ungarische Notation, die Pascal interne Namenkonvention (T für Typ, P für Pointer, E für Exception, I für Interface) und eine vernünftige (englische) Benennungskonvention beibringt ist es kompletter Müll. (...) und auch wenn Eigenlob stinkt, ich schreibe aktuell an einem FreePascal Tutorial: Link (Deutsch).

Habe gerade dein Tutorial überflogen. Gefällt mir eigentlich gut. Aber über Konventionen wie Ungarische Notation, die Pascal interne Namenskonvention (T für Typ, P für Pointer, E für Exception, I für Interface) und eine vernünftige (englische) Benennungskonvention habe ich nichts gefunden --> leider auch nur kompletter Müll.

[Warf]

Wirf dieses Tutorial mal bitte ganz schnell weg. Wenn es dir keine Konventionen wie Ungarische Notation, die Pascal interne Namenkonvention (T für Typ, P für Pointer, E für Exception, I für Interface) und eine vernünftige (englische) Benennungskonvention beibringt ist es kompletter Müll. (...) und auch wenn Eigenlob stinkt, ich schreibe aktuell an einem FreePascal Tutorial: Link (Deutsch).

Habe gerade dein Tutorial überflogen. Gefällt mir eigentlich gut. Aber über Konventionen wie Ungarische Notation, die Pascal interne Namenskonvention (T für Typ, P für Pointer, E für Exception, I für Interface) und eine vernünftige (englische) Benennungskonvention habe ich nichts gefunden --> leider auch nur kompletter Müll.

Englische Namen:

Konvention: Bei der Namensgebung in der Programmierung sollte man am besten Englische Namen vergeben, also statt z.B. Berechne nehmen wir Evaluate

Camel Hop notation:

Konvention: In Pascal spielt Groß- und Kleinschreibung keine Rolle, daher hat man sich auf die Konvention geeinigt, alle Namen mit einem Großbuchstaben anzufangen, und jedes weitere Wort auch wieder groß zu schreiben (z.B. WriteLn besteht aus dem Wort Write und Ln als Abkürzung für Line, d.h. wir schreiben das W und das L groß). Bei Variablennamen braucht man sich allerdings nicht an diese Konvention zu halten.

Klammernotation:

Konvention: Pascal benötigt zwar nicht die Leeren klammern () nach einem Funktion, doch um direkt unterscheiden zu können, bei was es sich um einem Funktion, sog. Funktion, handelt, und was eine Variable ist, schreibt man sie für gewöhnlich dennoch hin.

Benennung:

Konvention: Die Benennung von Typen geht TTypName für normale Typen (T für Type) PTyp für Zeiger (P für Pointer) und ETyp für Fehler (E für Exception). Zeiger haben hierbei den selben Namen wie der Typ nur das T wird durch ein P ersetzt.

Einfach mal bei dem Tutorial STRG+F drücken und Konvention suchen, da findet man einiges
In den Bemerkungen und Warnungen stehen auch noch einige lustige kleine Informationen über solche Konventionen, und in jedem Praktischen Beispiel halte ich mich auch daran. der Teufel liegt im Detail

[wp_xyz]

Ich will das nicht vertiefen, und ich finde das Tutorial auch wirklich gut (bis auf das, dass ich Navigationslinks z.B. ins Inhaltsverzeichnis vermisse). Der Rest war sarkastisch gemeint, denn arrogante Bemerkungen wie "das ist kompletter Müll" reizen zum Widerspruch. Und sooo schlecht finde ich das andere Tutorial auch wieder nicht.

P.S. Bei den Konventionen würde ich aus leidiger Erfahrung sogar auch dafür stimmen, dass Kommentare auf Englisch sind, zumindest wenn es die geringste Chance gibt, dass jemand ohne Deutschkenntnisse die Quelltexte zu Gesicht bekommt. Leider gibt es auch in der LCL manche Unit mit portugiesischen/spanischen (?) Kommentaren und sogar Variablenbezeichnungen (grids).

[mischi]

Ein Tutorial aus dem Jahr 2009, dessen "Hello World"-Beispiel die Units crt und dos benutzt, erweckt nicht gerade den Eindruck, dass es aktuell ist. Aus den Kapiteln 1-10 könnte man allerdings ein Tutorial für iso-Pascal machen.