Home  |  Delphi data types

 Writing your first program
 Writing your second program
 Amending this program

 Delphi data types
   Text (strings and chars)
   Sets and enumerations

 Programming logic
   Exception handling

 Dates and times



 Printing text and graphics

 Object Orientation basics
   Memory leaks!
   An example class


 Standard components


 A brief history of Delphi

 Usability : file handling

 Usability : reference books

 Author links

  Delphi data types
Storing data in computer programs
For those new to computer programming, data and code go hand in hand. You cannot write a program of any real value without lines of code, or without data. A Word Processor program has logic that takes what the user types and stores it in data. It also uses data to control how it stores and formats what the user types and clicks.
Data is stored in the memory of the computer when the program runs (it can also be stored in a file, but that is another matter beyond the scope of this tutorial). Each memory 'slot' is identified by a name that the programmer chooses. For example LineTotal might be used to name a memory slot that holds the total number of lines in a Word Processor document.
The program can freely read from and write to this memory slot. This kind of data is called a Variable. It can contain data such as a number or text. Sometimes, we may have data that we do not want to change. For example, the maximum number of lines that the Word Processor can handle. When we give a name to such data, we also give it its permanent value. These are called constants.

Simple Delphi data types
Like many modern languages, Delphi provides a rich variety of ways of storing data. We'll cover the basic, simple types here. Before we do, we'll show how to define a variable to Delphi:
 var                     // This starts a section of variables
   LineTotal : Integer;  // This defines an Integer variable called LineTotal
   First,Second : String;// This defines two variables to hold strings of text

We'll show later exactly where this var section fits into your program. Notice that the variable definitions are indented - this makes the code easier to read - indicating that they are part of the var block.
Each variable starts with the name you choose, followed by a : and then the variable type. As with all Delphi statements, a ; terminates the line. As you can see, you can define multiple variables in one line if they are of the same type.
It is very important that the name you choose for each variable is unique, otherwise Delphi will not know how to identify which you are referring to. It must also be different from the Delphi language keywords. Don't worry, you don't need to come up with an unusually creative name for each of your variables. Unique in this case simply means the only occurrence. You'll know when you have got it right when Delphi compiles your code OK (by hitting Ctrl-F9 to compile).
Delphi is not sensitive about the case (lower or upper) of your names. It treats theCAT name the same as TheCat.
Number types
Delphi provides many different data types for storing numbers. Your choice depends on the data you want to handle. Our Word Processor line count is an unsigned Integer, so we might choose Word which can hold values up to 65,535. Financial or mathematical calculations may require numbers with decimal places - floating point numbers.
  // Integer data types :
   Int1 : Byte;    //                        0 to 255
   Int2 : ShortInt;//                     -127 to 127
   Int3 : Word;    //                        0 to 65,535
   Int4 : SmallInt;//                  -32,768 to 32,767
   Int5 : LongWord;//                        0 to 4,294,967,295
   Int6 : Cardinal;//                        0 to 4,294,967,295
   Int7 : LongInt; //           -2,147,483,648 to 2,147,483,647
   Int8 : Integer; //           -2,147,483,648 to 2,147,483,647
   Int9 : Int64; // -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
  // Decimal data types :
   Dec1 : Single;  //  7  significant digits, exponent   -38 to +38
   Dec2 : Currency;// 50+ significant digits, fixed 4 decimal places
   Dec3 : Double;  // 15  significant digits, exponent  -308 to +308
   Dec4 : Extended;// 19  significant digits, exponent -4932 to +4932

Some simple numerical variable useage examples are given below - fuller details on numbers is given in the Numbers tutorial.
Text types
Like many other languages, Delphi allows you to store letters, words, and sentences in single variables. These can be used to display, to hold user details and so on. A letter is stored in a single character variable type, such as Char, and words and sentences stored in string types, such as String.
   Str1 : Char;       // Holds a single character, small alphabet
   Str2 : WideChar;   // Holds a single character, International alphabet
   Str3 : AnsiChar;   // Holds a single character, small alphabet
   Str4 : ShortString;// Holds a string of up to 255 Char's
   Str5 : String;     // Holds strings of Char's of any size desired
   Str6 : AnsiString; // Holds strings of AnsiChar's any size desired
   Str7 : WideString; // Holds strings of WideChar's of any size desired

Some simple text variable useage examples are given below - fuller details on strngs and characters is given in the Text tutorial.
Logical data types
These are used in conjunction with programming logic. They are very simple:
   Log1 : Boolean;    // Can be 'True' or 'False'

Boolean variables are a form of enumerated type. This means that they can hold one of a fixed number of values, designated by name. Here, the values can be True or False. See the tutorials on Logic and Looping for further details.
Sets, enumerations and subtypes
Delphi excels in this area. Using sets and enumerations makes your code both easier to use and more reliable. They are used when categories of data are used. For example, you may have an enumeration of playing card suits. You literally enumerate the suit names. Before we can have an enumerated variable, we must define the enumeration values. This is done in a type section.
   TSuit = (Hearts, Diamonds, Clubs, Spades);   // Defines the enumeration
   suit : TSuit;                                // An enumeration variable

Sets are often confused with enumerations. The difference is tricky to understand. An enumeration variable can have only one of the enumerated values. A set can have none, 1, some, or all of the set values. Here, the set values are not named - they are simply indexed slots in a numeric range. Confused? Well, here is an example to try to help you out. It will introduce a bit of code a bit early, but it is important to understand.
   TWeek = Set of 1..7;            // Set comprising the days of the week, by number
   week : TWeek;
   week := [1,2,3,4,5];     // Switch on the first 5 days of the week

See the Set reference, and the Sets and enumerations tutorial for further details. That tutorial introduces a further data type - a subrange type.

Using these simple data types
Variables can be read from and written to. This is called assignment. They can also be used in expressions and programming logic. See the Text tutorial and Programming logic tutorial for more about these topics.
Assigning to and from variables
Variables can be assigned from constant values, such as 23 and 'My Name', and also from other variables. The code below illustrates this assignment, and also introduces a further section of a Delphi program : the const (constants) section. This allows the programmer to give names to constant values. This is useful where the same constant is used throughout a program - a change where the constant is defined can have a global effect on the program.
Note that we use upper case letters to identify constants. This is just a convention, since Delphi is not case sensitive with names (it is with strings). Note also that we use = to define a constant value.
   TWeek = 1..7;            // Set comprising the days of the week, by number
   TSuit = (Hearts, Diamonds, Clubs, Spades);   // Defines an enumeration
   FRED          = 'Fred';      // String constant
   YOUNG_AGE     = 23;          // Integer constant
   TALL : Single = 196.9;       // Decimal constant
   NO            = False;       // Boolean constant
   FirstName, SecondName : String;  // String variables
   Age                   : Byte;    // Integer variable
   Height                : Single;  // Decimal variable
   IsTall                : Boolean; // Boolean variable
   OtherName             : String;  // String variable
   Week                  : TWeek;   // A set variable
   Suit                  : TSuit;   // An enumeration variable
 begin  // Begin starts a block of code statements
   FirstName  := FRED;         // Assign from predefined constant
   SecondName := 'Bloggs';     // Assign from a literal constant
   Age        := YOUNG_AGE;    // Assign from predefined constant
   Age        := 55;           // Assign from constant - overrides YOUNG_AGE
   Height     := TALL - 5.5;   // Assign from a mix of constants
   IsTall     := NO;           // Assign from predefined constant
   OtherName  := FirstName;    // Assign from another variable
   Week       := [1,2,3,4,5];  // Switch on the first 5 days of the week
   Suit       := Diamonds;     // Assign to an enumerated variable
 end;   // End finishes a block of code statements

 FirstName  is now set to 'Fred'
 SecondName is now set to 'Bloggs'
 Age        is now set to 55
 Height     is now set to 191.4
 IsTall     is now set to False
 OtherName  is now set to 'Fred'
 Week       is now set to 1,2,3,4,5
 Suit       is now set to Diamonds  (Notice no quotes)

Note that the third constant, TALL, is defined as a Single type. This is called a typed constant. It allows you to force Delphi to use a type for the constant that suits your need. Ohterwise, it will make the decision itself.

Compound data types
The simple data types are like single elements. Delphi provides compound data types, comprising collections of simple data types.
These allow programmers to group together variables, and treat this group as a single variable. When we discuss programming logic, you will see how useful this can be.
Array collections are accessed by index. An array holds data in indexed 'slots'. Each slot holds one variable of data. You can visualise them as lists. For example:
   Suits : array[1..4] of String;   // A list of 4 playing card suit names
   Suits[1] := 'Hearts';   // Assigning to array index 1
   Suits[2] := 'Diamonds'; // Assigning to array index 2
   Suits[3] := 'Clubs';    // Assigning to array index 3
   Suits[4] := 'Spades';   // Assigning to array index 4

The array defined above has indexes 1 to 4 (1..4). The two dots indicate a range. We have told Delphi that the array elements will be string variables. We could equally have defined integers or decimals.
For more on arrays, see the Arrays tutorial.
Records are like arrays in that they hold collections of data. However, records can hold a mixture of data types. Ther are a very powerful and useful feature of Delphi, and one that distinguishes Delphi from many other languages.
Normally, you will define your own record structure. This definition is not itself a variable. It is called a data type (see Types for further on this). It is defined in a type data section. By convention, the record type starts with a T to indicate that it is a type not real data (types are like templates). Let us define a customer record:
   TCustomer Record
     firstName : string[20];
     lastName  : string[20];
     age       : byte;

Note that the strings are suffixed with [20]. This tells Delphi to make a fixed space for them. Since strings can be a variable length, we must tell Delphi so that it can make a record of known size. Records of one type always take up the same memory space.
Let us create a record variable from this record type and assign to it:
   customer : TCustomer;           // Our customer variable
   customer.firstName := 'Fred';   // Assigning to the customer record
   customer.lastName  := 'Bloggs';
   customer.age       := 55;

 customer.firstName is now set to 'Fred'
 customer.lastName  is now set to 'Bloggs'
 customer.age       is now set to 55

Notice how we do not use an index to refer to the record elements. Records are very friendly - we use the record element by its name, separated from the record name by a qualifying dot. See the Records tutorial for further on records.
Objects are collections of both data and logic. They are like programs, but also like data structures. They are the key part of the Object oriented nature of Delphi. See the Object orientation tutorial for more on this advanced topic.

Other data types
The remaining main object types in Delphi are a mixed bunch:
File variables represent computer disk files. You can read from and write to these files using file access routines. This is a complex topic covered in Files.
Pointers are also the subject of an advanced topic - see Pointer reference. They allow variables to be indirectly referenced.
Variants are also an advanced topic - see Variant. They allow the normal Delphi rigid type handling to be avoided. Use with care!

Type definitions
When we discussed Records above, we introduced the concept of types. Delphi has many predefined data types - both simple, such as string, and compound, such as TPoint (which holds X and Y coordinates of a point). See Type for further details.

Delphi Basics © Neil Moffatt All rights reserved.  |  Home Page