Data Types & Variables Grade 10

Every value in Delphi has a data type. Variables are the containers that hold these values while your program runs. Constants hold values that never change.

Data Types

rTotalStock := iBoxesIn + iBoxesReturned;   // fine — a whole number fits happily into a Real
iBoxesIn    := rTotalStock * 2;             // rejected — a Real value won't fit into an Integer

Variables

A variable is a named storage location that holds a value during program execution. Think of it as a labelled cup — it holds one thing at a time, but you can empty it and refill it whenever you like.

Variables must be: Declared → Populated → Used.

Rules for Variable Names

Delphi won't accept just any piece of text as a variable name — a handful of rules apply every time you choose one:

• It has to begin with a letter or an underscore _ — never a digit or another symbol
• Spaces are not allowed anywhere in the name
• Once past the first character, digits and underscores may join the letters — but nothing else
• You can't reuse one of Delphi's own reserved words, since words like begin, var or end already have a fixed meaning to the compiler
• Delphi stops paying attention after the 255th character, so an extremely long name gains you nothing beyond that point

Naming Convention — Prefixes

Declaring Variables

Declaring a variable means creating a named container that we can populate later, in the var section, using the format: variableName : DataType;

Local Declaration (inside a procedure)

procedure TForm1.btnClickClick(Sender: TObject);
var
  sName:   string;
  iNumber: integer;
begin
  // code here
end;

Global Declaration (available to all procedures)

var
  Form1:   TForm1;
  sName:   string;   // declared here, below existing var block
  iNumber: integer;

Populating (Assigning) Variables

Use the assignment operator := to put a value into a variable that has already been declared.

sName   := 'Jannie';
sName   := edtName.Text;        // from a text box
iNumber := 15;
iNumber := sedNum.Value;         // from a spin edit
bFlag   := True;

Initialising Variables

i        := 0;
iTotal   := 0;
sReverse := '';
cLetter  := '';

Using Variables

lblFullName.Caption := sName + ' ' + sSurname;
memOut.Lines.Add(sName + ' ' + sSurname);
iAnswer := iNum1 + iNum2;
memOut.Lines.Add(IntToStr(iNum1) + ' + ' + IntToStr(iNum2)
               + ' = ' + IntToStr(iAnswer));

lblResult.Caption := 'Test 1: 78%' + #13 + 'Test 2: 84%';
memOut.Lines.Add('Player' + #9 + 'Score');

Incrementing and Decrementing Variables

Instead of writing out a full assignment every time a counter needs to move up or down by one, Delphi gives you two ready-made procedures: Inc and Dec. Call one with just the variable name and it steps by one; give it a second number and it steps by that amount instead.

Getting Input with InputBox

Not every value needs its own Edit box sitting on the form. The InputBox function opens a small dialog of its own, waits for the user to type something, and hands back whatever they entered — always packaged as a string, no matter what kind of data it looks like.

sTeam := InputBox('House Team', 'Which house are you in?', '');

Since the result is always text, wrap it in a conversion function whenever you actually need a number or a single character:

Constants

A constant holds a value that is known before the program runs and cannot change while it runs. Use const instead of var. No data type is needed, and use = not :=.

const
  VAT       = 0.15;
  MAX_ITEMS = 100;

// Using a constant — exactly like a variable
rVatAmount := rCostPrice * VAT;
rTotal     := rCostPrice + rVatAmount;

Type Conversion

Components like TEdit only hold strings. You must convert to the right type before using in calculations.

var
  iValue, iCode : Integer;
begin
  Val(edtAge.Text, iValue, iCode);
  if iCode = 0 then
    ShowMessage('Valid number: ' + IntToStr(iValue))
  else
    ShowMessage('Not a valid number!');   // iCode = position of the bad character
end;

Formatting Real Numbers

// FloatToStrF(value, format, totalDigits, decimals)
lblPrice.Caption := FloatToStrF(rPrice, ffCurrency, 4, 2);  // → R24.50
lblPrice.Caption := FloatToStrF(rPrice, ffFixed,    4, 2);  // → 24.50

Types of Errors

Only a syntax error stops the program from compiling at all — Delphi catches it immediately. Runtime and logical errors both let the program compile and run, which makes them harder to catch: a runtime error only shows itself when the exact conditions that break it occur (e.g. the user finally types a letter instead of a number), and a logical error may never show itself at all — the program keeps running and simply produces the wrong answer.

Preventing and Handling Runtime Errors with Try..Except

A try..except block protects against any runtime error, not just a bad conversion. Code that might fail — a conversion, a calculation, anything risky — goes inside the try section. The moment something in there raises an error, Delphi abandons whatever was left in that section and jumps straight to except, running the recovery code written there instead of letting the program crash.

try
  // risky code that might raise a runtime error
except
  // code that runs only if an error occurred above
end;

var
  rAmount : real;
begin
  try
    rAmount := StrToFloat(edtAmount.Text);
  except
    ShowMessage('Invalid amount entered');
  end;
end;

Finding Logical Errors — Debugging Tools

Logical errors are the hardest to find because the program runs without crashing. Besides tracing the code by hand with a paper-based trace table, Delphi's built-in debugger lets you watch a program execute one line at a time and see exactly what is happening inside it.