Können IDS werden dupliziert, über die Fälle der Variante record in FreePascal?

Hier ist mein problem: ich möchte ein record-Typ, wo unter den Fällen der Variante record, einige, aber nicht alle, haben einen bestimmten Bereich. Nach der wiki, ist dies vollkommen legal. Und doch, wenn ich versucht zu kompilieren, den folgenden code:

program example;

{$mode objfpc}{$H+}

uses sysutils;

type
  maritalStates = (single, married, widowed, divorced);

  TPerson = record
    name: record
      first, middle, last: string;
    end;
    sex: (male, female);
    dob: TDateTime;
    case maritalStatus: maritalStates of
      single: ( );
      married, widowed: (marriageDate: TDateTime);
      divorced: (marriageDate, divorceDate: TDateTime;
        isFirstDivorce: boolean)      
  end;

var
  ExPerson: TPerson;

begin
ExPerson.name.first := 'John';
ExPerson.name.middle := 'Bob';
ExPerson.name.last := 'Smith';
ExPerson.sex := male;
ExPerson.dob := StrToDate('05/05/1990');
ExPerson.maritalStatus := married;
ExPerson.marriageDate := StrToDate('04/01/2015');

end.

schlägt die Kompilierung fehl mit der folgenden Fehlermeldung:

$ fpc ex.pas
Free Pascal Compiler version 3.0.0 [2016/02/14] for x86_64
Copyright (c) 1993-2015 by Florian Klaempfl and others
Target OS: Win64 for x64
Compiling ex.pas
ex.pas(19,18) Error: Duplicate identifier "marriageDate"
ex.pas(21,3) Error: Duplicate identifier "marriageDate"
ex.pas(35,4) Fatal: There were 2 errors compiling module, stopping
Fatal: Compilation aborted
Error: C:\lazarus\fpc\3.0.0\bin\x86_64-win64\ppcx64.exe returned an error exitcode

Ist das wiki einfach falsch, oder bin ich hier etwas fehlt? Gibt es eine Möglichkeit, um diesen Effekt zu erzielen, die ich will?

Genial! Das klappte! Möchten Sie dies als Antwort, damit kann ich markierte die Frage gelöst, oder willst du mir es beantworten?
Wiki ist les-und schreibbar für alle, die sich registriert, und ist nicht MAßGEBEND. Es sind keine FPC-Menschen, die in der Liste der Mitwirkenden zu dieser Seite. Es könnte auch getan werden, indem sb mit einem anderen Modus (.e.g ISO-oder Macpas).
FWIW, ISTM, dass die Menschen können geschiedene und verwitwete oder verheiratet. Oder alle diese. Sie können auch geschieden und single. <g>

InformationsquelleAutor Kevin Keith | 2016-04-21

3

Sehr interessante Frage. Ich war sicher, dass dies möglich ist. Wenn Sie Ihren code so abändern:
```
..
married, widowed, divorced: (marriageDate: TDateTime);
divorced: (divorceDate: TDateTime; isFirstDivorce: boolean)
..
```
es funktioniert, aber es ist nicht das Ergebnis, das Sie haben möchten. Da marriageDate und die divorceDate überlagern einander (wie erwähnt in den Kommentaren!)

Diesem Bild ist entnommen aus "Pascal-Benutzer-Handbuch (4. Auflage)" und wie sehen Sie die Variante, die Teile haben die gleiche Speicherposition.

Laut Pascal-Benutzer-Handbuch (4. Auflage) und zu dem Buch "Turbo Pascal ISBN 3-89011-060-6 dem beschriebenen record-Deklaration auf Ihr Angebot wiki ist nicht gültig!
1. Alle Feldnamen müssen eindeutig sein - selbst wenn Sie auftreten in verschiedenen Varianten.
2. Wenn eine Variante leer ist (d.h., hat keine Felder), die form:
  C:()
3. Ein Feld Liste kann nur eine Variante Teil und es Folgen muss, die fester Bestandteil des Datensatzes.
4. Eine Variante kann sich selbst enthalten eine Variante Teil; daher Variante Teile können Ineinander verschachtelt werden.
5. Rahmen von Aufzählungstyp-Konstanten Bezeichner, die eingeführt werden, sind in einem record-Typ erstreckt sich über den umschließenden block.
Punkt 1 ist das relevant hier! Das Buch "Turbo Pascal" ist die vorgeschlagene Lösung verwenden Sie ein eindeutiges Präfix für die Feld-Namen, die mehrfach vorkommen.

In Ihrem Fall Ihren konnte würde wie folgt Aussehen:
```
TPerson = record
    name: record
      first, middle, last: string;
    end;
    sex: (male, female);
    dob: TDateTime;
    case maritalStatus: maritalStates of
      single: ( );
      married, widowed: (marMarriageDate: TDateTime);
      divorced: (divMarriageDate, divorceDate: TDateTime;
        isFirstDivorce: boolean)      
  end;
```
Die andere Lösung wäre zu definieren, verheiratet, devorced ... als record-Typ.
```
..
married       : (m: TMarried);
divorced      : (d: TDivorced);
..
```
- In diesem Fall marriageDate und die divorceDate overlay jede andere. Wenn Sie zuweisen marriageDate, werden Sie Lesen, das gleiche Datum aus divorceDate. IOW, Sie belegen den gleichen Speicherbereich.
- Wie Allen sagte, dies ist nicht die Lösung. Aber wahrscheinlich können Sie erklären, die einzelnen Teile als Datensatz-Typen im Voraus, und verwenden Sie diese als Arten von teilen der Variante.
- Du hast Recht. Ich werde schauen araund für eine Lösung, und Morgen die richtige Antwort
- Ich Frage mich immer noch, warum jeder versucht, um es so kompliziert? marMarriageDate und vidMarriagedate überlappen, also warum nicht einfach ein marriageDate ist nicht - Variante? Die Tatsache, dass single brauchen nicht, eine Ehe Datum spielt keine Rolle. Benutzen Sie es einfach nicht. Und die Datensatz-Größe wird genau das gleiche sowieso.
InformationsquelleAutor Alexander Baltasar
1

Diese scheint zu funktionieren
```
program example;

{$mode objfpc}{$H+}

uses sysutils;

type
  TMarried          = record
                        marriageDate  : TDateTime
                      end;

  TDivorced         = record
                        marriageDate  : TDateTime;
                        divorceDate   : TDateTime;
                        isFirstDivorce: boolean
                      end;

  TWidowed          = TMarried;

  maritalStates = (single, married, widowed, divorced);

  TPerson = record
    name: record
      first, middle, last: string;
    end;
    sex: (male, female);
    dob: TDateTime;
    case maritalStatus: maritalStates of
      single        : ();
      married       : (m: TMarried);
      widowed       : (w: TWidowed);
      divorced      : (d: TDivorced);
  end;

var ExPerson: TPerson;

begin
  with ExPerson do
  begin
    name.first := 'John';
    name.middle := 'Bob';
    name.last := 'Smith';
    sex := male;
    dob := StrToDate('05/05/1990');
    maritalStatus := married;
    m.marriageDate := StrToDate('04/01/2015');
  end;
end.
```
EDIT: Man könnte auch definieren, die die Datensätze inline, aber die oben ist klarer, denke ich. Hier ist die alternative:
```
program example;

{$mode objfpc}{$H+}

uses sysutils;

type
  maritalStates = (single, married, widowed, divorced);

  TPerson = record
    name: record
      first, middle, last: string;
    end;
    sex: (male, female);
    dob: TDateTime;
    case maritalStatus: maritalStates of
      single   : ();
      married  : (m: record marriageDate: TDateTime end);
      widowed  : (w: record marriageDate: TDateTime end);
      divorced : (d: record
                       marriageDate  : TDateTime;
                       divorceDate   : TDateTime;
                       isFirstDivorce: boolean
                     end)
  end;

var ExPerson: TPerson;

begin
  with ExPerson do
  begin
    name.first  := 'John';
    name.middle := 'Bob';
    name.last   := 'Smith';
    sex := male;
    dob := StrToDate('05/05/1990');
    maritalStatus  := married;
    m.marriageDate := StrToDate('04/01/2015');
  end;
end.
```
- Ja, es funktioniert, aber es ist übermäßig kompliziert. Einfach loszuwerden, die Variante Teil und setzen Sie alle Felder nach einander in den Datensatz. Das löst alle Probleme, ist viel einfacher und hat keine alignment-Probleme.
- Setzen Sie alle Felder in der Reihenfolge bläst den Datensatz. Dieser Fall war nur ein Beispiel. Es könnte viel mehr beteiligt. Betrachten Sie diesen Datensatz in einer Datei gespeichert, multipliziert mit 500 Millionen Menschen. Sogar ein einzelnes byte mehr, als benötigt werden, haben erhebliche Auswirkungen auf die Dateigröße. Es gab einen Grund, variant-records erfunden wurden. Auch eine Aufzeichnung ist garantiert gespeichert werden, als ein zusammenhängender Speicherblock, also ohne alignment-Probleme. (Wenn es nicht Sie wäre nicht möglich, es richtig zu verwenden, in einigen Fällen, z.B., wenn die Variante gemeint ist, einfach mal eine andere interpretation des gleichen Speicherplätze.)
- Setzen Sie alle Felder in der Reihenfolge nicht "aufblasen" der Platte. Die Variante Datensatz groß genug sein wird, zu halten alle Felder, also die größte Variante Teil bestimmt die Größe der Aufzeichnung zusammen mit dem festen Teil. Das wird genau die gleiche Größe wie die nicht-variant-record. Versuchen Sie es. Natürlich sollten Sie nur eine marriageDate man divorcedDate etc.
- Ich Maß Ihre version mit verschachtelten und anders benannte Datensätze in einer Variante Teil, und meine schlicht einfach aufnehmen, und beide sind Sie genau die gleiche Größe: 56 bytes. Ihr layout ist das gleiche, außer dass der Zugang zu Ihren Feldern haben, müssen Sie das Präfix mit mit m., w. oder d.. Beachten Sie, dass alle marriageDate Felder Ihres Datensatzes überschneiden sich sowieso. Also noch einmal: warum so kompliziert?
- FWIW, die Datensätze können, müssen sicherlich Problemen Ausrichtung, in FreePascal. Felder, die ausgerichtet sind auf Ihre natürlichen Grenzen, so dass ein 4-byte-Typ, die auf einer 4-byte-Grenze, etc. Die Ausrichtung des gesamten Datensatzes hängt von der Größe des größten Typs in der Aufzeichnung, und auch die Größe hängt davon ab.
- Ich fürchte, Sie nicht haben ein klares Verständnis von variant-records. Diese zwei Beispiele (gist.github.com/tonypdmtr/cae849750376d5cc7e2028e0835e385a), und versuchen Sie heraus zu finden, was Daten-Dateien, die Sie erstellen. Vergleichen Sie Größe und Inhalt.
- Ich habe eine sehr klare verstehen der Variante records (bin Programmierung in Pascal seit den frühen achtziger Jahren), und ich weiß, dass Gegenstände in der Variante, die Teile überlappen sich, so, ja, dein github-Beispiel-Datensätze haben unterschiedliche Größen. Aber nehmen Sie einen Blick auf meine Antwort und sagen Sie mir, welche der Datensätze größer ist: die, die Ihr vorschlagen oder mir, ohne Variante teilen. Ich denke, es ist an Ihnen, die Sie nicht vollständig verstehen, das layout der Variante records. Vertrauen Sie mir wenn ich Ihnen sage, dass es keinen Unterschied im layout. Meine marriageDate deckt alle von Ihnen, da Sie alle überlappen. und die extra-Felder müssen nicht sein, Variante entweder. Versuchen Sie es.
- Ich werde schreiben, ein Beispiel mit beiden layouts: Ihre und meine, und dann poste ich die offsets der Felder. Du wirst sehen, was ich meine. Aber wahrscheinlich nicht heute.
- Ich habe gerade udpated meine Antwort. Schauen Sie sich an, und versuchen Sie es selbst heraus. Wie Sie sehen können, w.marriageDate, m.marriageDate und d.marriageDatein Ihrem Datensatz haben alle den gleichen offset ist der gleiche wie der Versatz der marriageDate in meinem nicht-variant-record. Und die folgenden Felder haben natürlich die gleichen hohen offsets, genau das gleiche wie in meiner nicht-Variante aufnehmen. Variante records sicherlich Sinn machen, aber in diesem Fall nicht.
- Hmm, Letzte Versuch von mir: DIESER FALL WAR NUR EIN BEISPIEL. Wir werden nicht gefragt, ob eine Variante, die Platte macht es Sinn, in diesem speziellen Fall aber, wie man mit dem Problem der doppelten Namen. Ihr Versuch zu beweisen, dass die Variante Aufzeichnungen machen keinen Sinn, in diesem Fall ist nicht das Problem. Ich könnte unendliche Beispiele, zu. Offensichtlich, wenn die gemeinsamen Felder sind in allen variant-Teile, diese bewegen sich um den gemeinsamen Teil. Aber wenn Sie Variante verwenden Datensätze, wie Sie bei der Lösung der Namensfrage... wie auch immer, ich denke, wir können es jetzt ruhen.
- Ich bin nicht so sicher, dass dieser Fall war ein Beispiel, aber selbst wenn es waren, es zeigt deutlich, dass es nicht immer sinnvoll, Sie zu benutzen eine Variante aufgezeichnet, wenn eine einfache "flache" Aufnahme zu tun. Wenn mich jemand fragt "soll ich eine Tasche oder ein Brot Messer zum ändern eines Reifens", werde ich Ihnen sagen, dass es bessere tools.
- Ich könnte darauf hinweisen, ein paar Fehler in Ihrer Argumentation, aber ich will nicht.
InformationsquelleAutor tonypdmtr

Was Baltasar schlägt kompiliert wird, aber nicht tun, was Sie wollen. marriageDate und divorceDate überlappen und schreiben zu einem von Ihnen ändern auch die anderen, denn Sie sind einfach an die gleiche Adresse.

Aber in diesem Fall gibt es keinen guten Grund für eine Variante aufnehmen.

Warum nicht einfach:

type
  maritalStates = (single, married, widowed, divorced);

  TPerson = record
    name: record
      first, 
      middle, 
      last: string;
    end;
    sex: (male, female);
    dob: TDateTime;
    maritalStatus: maritalStates; // single, married, widowed, divorced
    marriageDate: TDateTime;      // married, widowed, divorced   
    divorceDate   : TDateTime;    // divorced
    isFirstDivorce: boolean;      // divorced
  end;

Die Benutzung und das layout ist genau das, was Sie brauchen. Wenn ein Feld nicht anwendbar (z.B. marriageDate für eine single oder divorceDate für eine married), die Sie einfach nicht verwenden.

Identisch ist mit einer Variante record. Dort gibt es auch nur die Felder, die angewendet werden. Beachten Sie, dass der compiler oder Laufzeit nicht verhindern, dass Sie vom schreiben auf das falsche Feld einer Variante record sowieso, also in einer Variante aufnehmen, wenn der status single können Sie noch schreiben oder Lesen von divorceDate, auch wenn das keinen Sinn macht.

Wenn Sie unterscheiden wollen verschiedene setups, einfach das zu tun in den Kommentaren, und vergesst die Variante aufnehmen, Sie brauchen es nicht hier. Jetzt können Sie tun:

var
  P: TPerson;
begin
  P.name.first := 'Bob';
  P.name.middle := 'The';
  P.name.last := 'Builder';
  P.sex := male;
  P.dob := StrToDate('05/05/1980');
  P.maritalStatus := divorced;
  P.marriageDate := StrToDate('04/01/2013');
  P.divorceDate := StrToDate('04/02/2016');
  P.isFirstDivorce := True;

  // etc...

Update

Nur um zu zeigen, dass es absolut keine Notwendigkeit, diese Platte Variante,

Werde ich nach meinem Project62.dpr, der zeigt genau die gleichen offsets für die entsprechenden Felder ein und denselben Datensatz-Größen:

program Project62;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

type
  maritalStates = (single, married, widowed, divorced);
  tsex = (male, female);

  // No variant part
  PPerson = ^TPerson;
  TPerson = record
    name: record
      first,
      middle,
      last: string;
    end;
    sex: tsex;
    dob: TDateTime;
    maritalStatus: maritalStates; // single, married, widowed, divorced
    marriageDate: TDateTime;      // married, widowed, divorced
    divorceDate   : TDateTime;    // divorced
    isFirstDivorceDate: boolean;      // divorced
  end;

  // Variant part like tonypdmtr's record
  PPerson2 = ^TPerson2;
  TPerson2 = record
    name: record
      first,
      middle,
      last: string;
    end;
    sex: tsex;
    dob: TDateTime;
    case maritalStatus: maritalStates of
      single:   ();
      widowed:  (w: record marriageDate: TDateTime; end); // overlaps with m.marriageDate and d.marriageDate
      married:  (m: record marriageDate: TDateTime; end); // overlaps with w.marriageDate and d.marriageDate
      divorced: (d: record
                      marriageDate: TDateTime;            // overlaps with w.marriageDate and m.marriageDate
                      divorceDate: TDateTime;             // same offset as in my non-variant version
                      isFirstDivorceDate: Boolean         // same offset as in my non-variant version
                    end);
  end;

begin
  try
    Writeln('TPerson:  size = ', Sizeof(TPerson));
    Writeln('TPerson.maritalStatus:         offset = ', NativeUInt(@PPerson(nil)^.maritalStatus));
    Writeln('TPerson.marriageDate:          offset = ', NativeUInt(@PPerson(nil)^.marriageDate));
    Writeln('TPerson.divorceDate:           offset = ', NativeUInt(@PPerson(nil)^.divorceDate));
    Writeln('TPerson.isFirstDivorceDate:    offset = ', NativeUInt(@PPerson(nil)^.isFirstDivorceDate));
    Writeln;
    Writeln('TPerson2:  size = ', Sizeof(TPerson2));
    Writeln('TPerson2.maritalStatus:        offset = ', NativeUInt(@PPerson2(nil)^.maritalStatus));
    Writeln('TPerson2.w.marriageDate:       offset = ', NativeUInt(@PPerson2(nil)^.w.marriageDate));
    Writeln('TPerson2.m.marriageDate:       offset = ', NativeUInt(@PPerson2(nil)^.m.marriageDate));
    Writeln('TPerson2.d.marriageDate:       offset = ', NativeUInt(@PPerson2(nil)^.d.marriageDate));
    Writeln('TPerson2.d.divorceDate:        offset = ', NativeUInt(@PPerson2(nil)^.d.divorceDate));
    Writeln('TPerson2.d.isFirstDivorceDate: offset = ', NativeUInt(@PPerson2(nil)^.d.isFirstDivorceDate));
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;
end.

Ausgabe (unter Windows):

TPerson:  size = 56
TPerson.maritalStatus:         offset = 24
TPerson.marriageDate:          offset = 32
TPerson.divorceDate:           offset = 40
TPerson.isFirstDivorceDate:    offset = 48

TPerson2:  size = 56
TPerson2.maritalStatus:        offset = 24
TPerson2.w.marriageDate:       offset = 32
TPerson2.m.marriageDate:       offset = 32
TPerson2.d.marriageDate:       offset = 32
TPerson2.d.divorceDate:        offset = 40
TPerson2.d.isFirstDivorceDate: offset = 48

Layout in 32 bit kann gesetzt werden, um ein einfaches Diagramm, in etwa so:

  00 TPerson: [name.first]          TPerson2: [name.first]
  04          [name.middle]                   [name.middle]
  08          [name.last]                     [name.last]
  12          [sex]                           [sex]
  16          [dob]                           [dob]
  24          [maritalStatus]                 [maritalStatus]
  32          [marriageDate]                  [w.marriageDate] [m.marriageDate] [d.marriageDate]
  40          [divorceDate]                                                     [d.divorceDate]
  48          [isFirstDivorceDate]                                              [d.isFirstDivorceDate]

InformationsquelleAutor Rudy Velthuis

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.