Difference between revisions of "Record"
m (→Variable structure: Correcting old error with duplicate identifier and misleading comment about variable parts. Added new example.) |
m (→Variable structure: prefixed the type with 'T' and changed it to singular) |
||
Line 26: | Line 26: | ||
<syntaxhighlight lang="pascal" highlight="12-13"> | <syntaxhighlight lang="pascal" highlight="12-13"> | ||
type | type | ||
− | + | TMaritalState = (single, married, widowed, divorced); | |
TPerson = record | TPerson = record | ||
// CONSTANT PART | // CONSTANT PART | ||
Line 37: | Line 37: | ||
dob: TDateTime; | dob: TDateTime; | ||
// VARIABLE PART | // VARIABLE PART | ||
− | case | + | case maritalState: TMaritalState of |
single: ( ); | single: ( ); | ||
married, widowed: (marriageDate: TDateTime); | married, widowed: (marriageDate: TDateTime); | ||
Line 46: | Line 46: | ||
Note that fields of the variable part have to be in parentheses. You cannot use the same identifier multiple times, so a slightly different name has to be used for the <code>marriageDate</code> in case of ''divorced''. | Note that fields of the variable part have to be in parentheses. You cannot use the same identifier multiple times, so a slightly different name has to be used for the <code>marriageDate</code> in case of ''divorced''. | ||
− | The variable part shares the same memory. So <code>marriageDate</code> and <code>marriageDateDivorced</code> will have the same value regardless of <code> | + | The variable part shares the same memory. So <code>marriageDate</code> and <code>marriageDateDivorced</code> will have the same value regardless of <code>maritalState</code>. This behaviour is particularly practical as the following example shows: |
<syntaxhighlight lang="pascal" highlight="3"> | <syntaxhighlight lang="pascal" highlight="3"> | ||
type | type |
Revision as of 16:24, 31 July 2020
│
Deutsch (de) │
English (en) │
español (es) │
suomi (fi) │
français (fr) │
magyar (hu) │
polski (pl) │
português (pt) │
русский (ru) │
A record
is a highly structured data type
in Pascal.
They are widely used in Pascal, to group data items together logically.
While simple data structures such as array
s or sets consist of elements all of the same type, a record can consist of a number of elements of different types, and can take on a huge complexity.
Each separate part of a record is referred to as a field.
The record is reserved word.
Declaration
Fixed structure
type
TMember = record
firstname, surname : string;
address: array [1..3] of string;
phone: string;
birthdate: TDateTime;
paidCurrentSubscription: boolean
end;
Variable structure
And even more complex structures are possible, e.g.:
type
TMaritalState = (single, married, widowed, divorced);
TPerson = record
// CONSTANT PART
// of course records may be nested
name: record
first, middle, last: string;
end;
sex: (male, female);
// date of birth
dob: TDateTime;
// VARIABLE PART
case maritalState: TMaritalState of
single: ( );
married, widowed: (marriageDate: TDateTime);
divorced: (marriageDateDivorced, divorceDate: TDateTime;
isFirstDivorce: boolean)
end;
Note that fields of the variable part have to be in parentheses. You cannot use the same identifier multiple times, so a slightly different name has to be used for the marriageDate
in case of divorced.
The variable part shares the same memory. So marriageDate
and marriageDateDivorced
will have the same value regardless of maritalState
. This behaviour is particularly practical as the following example shows:
type
TSpecialWord = record
case Byte of
0: (Word_value: Word); // 7
1: (Byte_low, Byte_high: Byte); // 7, 0
2: (Bits: bitpacked array [0..15] of 0..1); // 1, 1, 1, 0, 0, ...
end;
This record has only a variable part and enables access to the value of the word, the individual bytes and even to the bits. An identifier is not necessarily required in the case
clause, so this does not occupy any memory. The size of this record is two bytes. In the case of Bits
, this is only possible if bitpacked
is used. Note the order of the bytes, with the less significant byte (LSB) coming first.
Advanced record
An “advanced record” is a record with methods and properties.
{$modeSwitch advancedRecords}
(after you have set the mode).Addressing
Fields
Individual fields are accessed by placing a dot between the record name and the field name thus:
a.firstname := 'George';
a.surname := 'Petersen';
a.phone := '789534';
a.paidCurrentSubscription := true;
Alternatively, the whole series of fields can be made available together using the with
-construct:
with a do
begin
firstname := 'George';
surname := 'Petersen';
phone := '789534';
paidCurrentSubscription := true
end;
Instances
A record is treated by the program as a single entity, and for example a whole record can be copied (provided the copy is of the same type) thus:
var
a, b: TMember;
(* main program *)
begin
// ... assign values to the fields in record a
b := a
// Now b holds a _copy_ of a.
// Do not get confused with references:
// a and b still point to _different_ _entities_ of TMember.
end.
Constant record
type
// record definition
TSpecialDay = record
dayName: string;
month: integer;
day: integer;
end;
const
// TSpecialDay constant
christmasDay: TSpecialDay = (
dayName: 'Christmas Day';
month: 12;
day: 25;
);
See also
simple data types |
|
---|---|
complex data types |