Compiler weiss nicht welcher Typ?

[Pseudemys Nelsoni]

hoi,

ich habe aus meinem buch folgendes:

Delphi-Quellcode:

VAR 
  Quadrat1: Record
              obenlinks, untenrechts: TPunkt;
            end;
  Quadrat2: Record
              obenlinks, untenrechts: TPunkt;
            end;

dort steht nun das beide Typen zwar gleich sind, der Compiler das aber nicht weiss
da kein typ deklariert ist.

aber TPunkt ist doch ein typ oder nicht?

[choose]

Die Typen TPunkt sind zwar identisch, aber die Typen der Records nicht, so dass in Deinem Beispiel die Zuweisung
Quadrat1:= Quadrat2; nicht zugelassen werden wird, weil der Compiler sie nicht als identische Typen ansieht.

Stichworte für die OH: "Kompatibilität und Identität von Typen", "Typenidentität", "Typenkompatibiltät" und "Zuweisungskompatibilität"

Zitat von OH, leicht modifiziert:

Sprachkonstrukte, die als Typnamen fungieren, erzeugen bei jedem Auftreten einen anderen Typ. Die folgenden Typdeklarationen

Delphi-Quellcode:

type
  TS1 = set of Char;
  TS2 = set of Char;

definieren beispielsweise die beiden unterschiedlichen Typen TS1 und TS2. Entsprechend werden mit den Variablendeklarationen

Delphi-Quellcode:

var
  S1: string[10];
  S2: string[10];

zwei Variablen unterschiedlichen Typs erzeugt. Um Variablen mit identischem Typ zu deklarieren, gehen Sie folgendermaßen vor:
var S1, S2: string[10]; oder

Delphi-Quellcode:

type TMyString = string[10];
var
  S1: TMyString;
  S2: TMyString;

[Robert Marquardt]

Solche expliziten Typdeklarationen sind immer inkompatibel selbst wenn sie gleich sind.
Das ist auch der Grund warum man sie bei Parametern nicht benutzen kann.
Das ist eine alte Definition, die noch vom originalen Pascal kommt. Sie macht auch Sinn.
Gleich aussehen heist keinesfalls gleich sein. Ist bei Zwillingen ja auch nicht anders.

[Pseudemys Nelsoni]

welchen typ haben meine records eigentlich in meinem beispiel? ist ja garkeiner angegeben Oo

danke für die hilfe btw

[Robert Marquardt]

Natuerlich ist ein Typ angegeben. Der Typ hat nur keinen eigenen Namen.

[Sharky]

Erzeuge dir einfach einen Typ:

Code:

Type
  MyRecord = Record
              obenlinks, untenrechts: TPunkt;
             end;              
var
 Quadrat1,
 Quadrat2  : MyRecord;

[Pseudemys Nelsoni]

hoi sharky,

jo so stehts in meinem buch auch, ich verstehe nur nicht, wieso das beispiel siehe oben nicht klappt

Zitat:

Natuerlich ist ein Typ angegeben. Der Typ hat nur keinen eigenen Namen.

welcher denn?

[MrSpock]

Hallo Pseudemys Nelsoni,

es ist ein zusammengesetzter Record-Typ, der aus zwei Einträgen des Typs TPunkt besteht.

[choose]

Der Delphi-Compiler ordnet bei der Übesetzung jedem Ausdruck einen Typen zu, um überprüfen zu können, ob Zuweisungen zulässig sind, ob übergebene Parameter einem kompatiblen Typen entsprechen, der ggf Konvertiert werden kann, etc.
So hat zB der konstante Ausdruck
189+4 den impliziten Typ Byte zugeordnet. Bei einem Ausdruck der Form
4+3 jedoch den Typ 0..127 (nachzulesen in der OH "Echte Konstanten").
Bei der Deklaration von Variablen wird idR explizit ein Typ angegeben, zB

Delphi-Quellcode:

var
  myInt : Integer;

und der Compiler ist dank dieser Information später in der Lage zu entscheiden, ob eine Zuweisung der Form
myInt:= 189+4; zulässig ist (nachzulesen in der OH unter "Typkomatiblität"). Darüber hinaus kann er nur durch die Angabe des Typs den Operator (nein, es ist keine Funktion) SizeOf verwenden, also die Größe in Bytes zu einem Datentypen ermitteln, obwohl dieser Information nicht zu jeder Variablen abgelegt wird. Stattdessen greift er zu diesem Zweck auf seine eigene "Buchführung" zurück...

Es ist möglich, ohne einen benannten Typen, eine Variable zu deklarieren:

Delphi-Quellcode:

var
  myVar: record 
    AField: Integer;
  end;

Damit der Compiler später zB in der Lage ist, zu erkennen, dass die Zuweisung
myVar:= '6*9=42'; ungültig ist, aber auch um Konstrukte der Art
FillChar(myVar, SizeOf(myVar), 0); zu ermöglichen, muss der Compiler der Variablen myVar einen Typen zuordnen.
Aus Mangel an Unterstützung seitens des Programmiers ist der Compiler an dieser Stelle gezwungen, selbst einen Typen zu erstellen und zu ihm die notwendigen Informationen ablegen, allerdings verwendet er hierzu keinen für den Programmierer zugänglichen Namen und dieser Typ dient nur dem Compiler zur Übersetzungszeit. Wollte der Programmierer mit dieser Information arbeiten hätte er schließelich einen Typen in der Form

Delphi-Quellcode:

type
  TMyType = record
    AField: Integer;
  end;
var
  myVar: TMyType;

benannt

Wenn Du hingegen zweimal einen anonymen Typen erstellst, zB mit

Delphi-Quellcode:

var
  aString: string[10];
  anotherString: string[10];

wird der Compiler zweimal einen eigenen Typen erstellen, der nicht identisch ist mit dem Anderen (siehe hierzu die OH "Typenidentität"). Welche Konsequenzen das für Dein Programm, zB bei Zuweisungen der Art
aString:= anotherString hat, kannst Du in der OH unter "Zuweisungskompatibilität" nachlesen.

BTW: Dies ist auch der Grund warum Signaturen von Methoden, Funktionen und Prozeduren in der Form
procedure MyProc(var AValue: record AField: Integer; end;); unzulässig sind: Es gibt keinen kompatiblen Datentypen...


Das Prinzip, der anonymen Datentypen ist in anderen Sprachen noch weiter vertreten, bei denen man zB ein Exemplar einer Klasse (Objekt), die von einer anderen Erbt und zu der man ad-hoc eine Methode überschreibt, erzeugen kann ohne die Klasse zu benennen
Zum Verständnis in Pseudo-PascalCode:

Delphi-Quellcode:

var
  myObject: TMyClass;
  anotherObject: TMyClass;
begin
  myObject:= TMyClass.Create(Self);
  Showmessage(IntToStr(myObject.GetValue)); // e.g. '5'

  anotherObject:= (class(TMyClass)
    function GetValue: Integer; overload;
    begin
      Result:= (inherited GetValue) + 23;
    end; ).Create(Self);
  Showmessage(IntToStr(anotherObject.GetValue)); // '28'

wobei folgende Aussagen wahr wären:

Delphi-Quellcode:

anotherObject.InheritsFrom(TMyClass);
anotherObject.ClassType<>myObject.ClassType;
anotherObject is TMyClass;

[Pseudemys Nelsoni]

wow, super erklärt, danke =D.
Der letzte Abschnitt ist nur (noch) zu hoch für mich.


btw:

Zitat:

var
aString: string[10];
anotherString: string[10];

ist da nicht der typ angegeben? string?