Learn Pascal

Content

Backgournd Basics Input/Output Program Flow Data Types Subroutines

About Pascal Origins: ALGOL Inventor: Dr. Niklaus Wirth Date of Birth: 1971 Feature: Simple, Precise, Procedure-o

riented Classic Compilers: Turbo Pascal, Borla

nd Pascal, Free Pascal Extension: Object Pascal, Delphi

First Pascal Program

program Hello; begin WriteLn('Hello, world!'); end.

Program Structure

program ProgramName; const { Constant Declarations } type { Type Declarations } var { Variable Declarations }

Program Structure

{ Subroutine definitions } begin { Main program} end.

Comments

{ Comment } (* Comment *) // Line Comment, New in Delphi &

Free Pascal

Identifiers Name of programs, procedures, functi

ons, types, constants, variables, etc. Must begin with a letter or an undersc

ore(_) Can be followed by letters, digits, and

underscores NOT case-sensitive (i.e. ID=id=Id=iD)

Reserved Words

and array begin case

const div do downtoelse end file for

forward function goto if

in label mod nil

not of or packed

procedure

program record repeat

set then to type

until var while with

Types

Simple Type String Type Structured Type Pointer Type Procedural Type

Simple Types

Ordinary Types Integer Types Char Types Boolean Types

Real Types

Integer Types

Type Size Range

ShortInt 1 -128 .. 127

Integer 2 -32768 .. 32767

LongInt 4 -2147483648 .. 2147483647

Byte 1 0 .. 255

Word 2 0 .. 65535

Integer Types (Extension)

Type Size Range

SmallInt 2 -32768 .. 32767

LongWord

4 0 .. 4294967295

Int64 8 -263 .. 263-1

QWord 8 0 .. 264-1

Integer ? Platform Dependant

Cardinal ? Platform Dependant

Real Types

Type Size

Range Digits

Real ? Platform Dependant ?

Single 4 1.5E-45 .. 3.4E38 7-8

Double 8 5.0E-324 .. 1.7E308 15-16

Extended

10 1.9E-4951 .. 1.1E4932

19-20

Comp 8 The Same as Int64 19-20

Constants

const Identifier = value; // Cannot be modified Identifier : Type = value; // Can be modified

Constants Example: const Name = 'Han Wentao'; // string Message = 'That''s OK.'; // string FirstLetter = 'a'; // Char NewLine = #10; // Char Year = 2003; // Integer Pi = 3.141592653589793; // Real IsInDebugMode = True; // Boolean a : Real = 12; // Typed Real

Variables

var Identifier : Type; // Can be modified Example: var i, j, Count : Integer; FileName : string;

Assignment

Symbol: := Format: Variable := expression; Example: i := $FF; Count := 0; FileName := 'berry10.out';

Operators

Arithmetic Operators (+, -, *, /, mod, div)

Logical Operators (not, and, or, xor, shl, shr)

Boolean Operators (not, and, or, xor) Relation Operators (=, <>, <, >, <=, >=)

Assignment & Operators Examples

i := (123 + 456) * 789; q1 := (1 + 10) div 3; // q1=3,Integer q2 := (1 + 10) / 3; // q2=3.666667 Value := 123; Radix := 16; Remainder := Value mod Radix; // Remainder=11

Standard Routine

Read ReadLn Write

WriteLn Ord Chr

Pred Succ SizeOf

Concat Copy Delete

Insert Length Pos

Str Val UpCase

Standard Math Routine

Abs ArcTan Cos

Dec Exp FracHi Inc IntLn Lo Odd

Pi Random Randomize

Round Sin SqrSqrt Swap Trunc

Punctuation & Indentation You MUST have a semicolon(;)

following: the program heading each constant definition each variable declaration almost all statements

Indentation is not necessary but useful. It makes your program readable.

Program Task 1 Input 3 real numbers, a, b, c, from

keyboard, print out the 2 roots of the equation ax2+bx+c=0 on the screen. It is guaranteed that the roots must exist.

Sample Input 1 -3 2

Sample Output 2 1

My Solution for Task 1 program Task1; var a, b, c, Delta: Real; begin Read(a, b, c); Delta := Sqr(b) - 4 * a * c; WriteLn((-b + Sqrt(Delta)) / (2 * a)); WriteLn((-b - Sqrt(Delta)) / (2 * a)); end.

Input

Read(<Variable1>, <Variable2>, …); // does not skip to the next line unless

necessary ReadLn(<Variable1>, <Variable2>, …); // just a Read procedure that skips to t

he next line at the end of reading

Input ExampleWe input from keyboard:45 97 31 2 3

Statement(s) a b c d

Read(a);Read(b);

45 97

ReadLn(a);Read(b);

45 1

Read(a, b, c, d); 45 97 3 1

ReadLn(a, b);ReadLn(c, d);

45 97 1 2

Output

Write(<Expression1>, <Expression2>, …);

WriteLn(<Expression1>, <Expression2>, …);

// skips to the next line when done

Formatting Output

<Expression> : <Field Width> for reals: <Real Expression> : <Field Width> : <D

ecimal Field Width>

Output Example

Write('Hi' : 10, 5 : 4, 5673 : 2); ********Hi***55673 Write(573549.56792 : 20 : 2); ***********573549.57 Write(123.345 : 0 : 2); 123.35 // * represents a space

Text Files

Declaration: var FileVar : Text;

Access a File

Assign(<FileVar>, 'File Path & Name'); for input: Reset(<FileVar>); for output: Rewrite(<FileVar>); and DO NOT forget: Close(<FileVar>); at last!

Read and Write File

Read/ReadLn(<FileVar>, <Variable1>, <Variable2>, …);

Write/WriteLn(<FileVar>, <Expression1>, <Expression2>, …);

A Shortcut for input:

Assign(Input, 'File Path & Name'); Reset(Input);

for output: Assign(Output, 'File Path & Name'); Rewrite(Output); … Close(Output); // DO NOT FORGET

Test End of Line & End of File

Eoln(FileVar : Text) : Boolean; Eof(FileVar : Text) : Boolean;

Program Task 2

Read an angle from file trigono.in in degrees. Write the function sin, cos, tan, cot, sec and csc of the angle to the file trigono.out, rounded to 4 decimals. It is guaranteed that the angle is valid.

Program Task 2 Sample Input (trigono.in):

30 Sample Output (trigono.out):

0.5000 0.8660 0.5774 1.7321 1.1547 2.0000

My Solution for Task 2 program TrigonometricFunctions; const InputFileName = 'trigono.in'; OutputFileName = 'trigono.out'; var Deg, Rad, SinA, CosA: Real; begin Assign(Input, InputFileName); Reset(Input); Assign(Output, OutputFileName); Rewrite(Output); Read(Deg);

My Solution for Task2 Rad := Deg / 180 * Pi; SinA := Sin(Rad); CosA := Cos(Rad); WriteLn(SinA : 0 : 4); WriteLn(CosA : 0 : 4); WriteLn(SinA / CosA : 0 : 4); WriteLn(CosA / SinA : 0 : 4); WriteLn(1 / CosA : 0 : 4); WriteLn(1 / SinA : 0 : 4); Close(Input); Close(Output); end.

Sequential Control

Sequential control is the default. The computer executes each statement and goes on to the next statement until it sees an end.

Boolean Expressions Precedence

- not * / div mod and shr shl + - or xor = <> < > <= >=

Complex Boolean 3 > 5 or 650 < 1 // WRONG (3 > 5) or (650 < 1) // CORRECT

Real Value Comparison

DO NOT compare two real values with operator =. Small round-off errors may cause two equivalent expressions to differ.

Instead, use this comparison: const Epsilon = 1E-10; Abs(x1 - x2) <= Epsilon

Statement

Assignment Subroutine Call goto Compound Statement Conditional Statement Repetitive Statement

Compound Statement

begin Statement1; Statement2; … end;

IF Statement

if <BooleanExpression> then Statement; OR if <BooleanExpression> then Statement1 else Statement2;

IF Statement Pitfall

if <BooleanExpression1> then if <BooleanExpression2> then Statement1 else Statement2;

IF Statement Pitfall Correction

if <BooleanExpression1> then begin if <BooleanExpression2> then Statement1 end else Statement2;

IF Statement Extension if <BooleanExpression1> then Statement1 else if <BooleanExpression2> then Statement2 else if … … else Statement n;

CASE Statement

case <OrdinalExpression> of <OrdinalValueList1>: Statement1; <OrdinalValueList2>: Statement2; … else Statement end;

FOR Statement

for <OrdinalVariable>:=<LowerBound> to <UpperBound> do

Statement; OR for <OrdinalVariable>:=<UpperBound

> downto <LowerBound> do Statement;

WHILE Statement

while <BooleanExpression> do Statement;

REPEAT Statement

repeat Statement1; Statement2; … until <BooleanExpression>;

Break & Continue

Break jumps to the statement following the end of the current repetitive statement.

Continue jumps to the end of the current repetitive statement.

Program Task 3 Fibonacci sequence is defined by:

a1=1 a2=1 ai=ai-1+ai-2

Input a positive integer n(n<=20) from keyboard, print an.

Sample Input: 10 Output: 55

My Solution for Task 3 program Task3; var i, a, b, c, n: Integer; begin Read(n); a := 1; b := 1; for i := 3 to n do begin c := b; b := a + b; a := c; end; WriteLn(b); end.

Program Task 4 Display all powers of 2 that are <

2,000,000,000. Display the list in a properly formatted manner, with commas between the numbers. Display five numbers per line. The output should look like:

1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, …

My Solution for Task 4 program Task4; const N = 31; var i: Integer; begin for i := 1 to N do begin Write(1 shl (i - 1)); if i <> N then Write(','); if i mod 5 = 0 then WriteLn else Write(' '); end; if N mod 5 <> 0 then WriteLn; end.

Type Definition

type TypeIdentifier = TypeSpecification;

For example: type TName = string[25];

Enumerated Type

Format: (id1, id2, …) For example: type TWeek = (Sunday, Monday, Tuesday,

Wednesday, Thursday, Friday, Saturday);

Subrange Type Format: LowerBound .. UpperBound For example: type TDay = 1 .. 31; TWorkDay = Monday .. Friday;

Array Type

Format: array [LowerBound .. UpperBound]

of SomeType; For example: a: array [1 .. 100] of Integer; FillChar(a, SizeOf(a), 0); a[1] := 100;

Array Type

Multidimensional array: array [LowerBound1 .. UpperBound1,

LowerBound2 .. UpperBound2, …] of DataType;

Record Type

Format: record FieldNameList1: Type1; FieldNameList2: Type2; … end;

Record Type For example: TPerson= record Name: TName; Gender: (Male, Female); Age: 1 .. 200; Height, Weight: Real; end;

Set Type

Format: set of OrdinalType For example: set of Char; set of 1 .. 100;

Set Type a, b: set of 1 .. 100; Assignment:

a := [1 .. 10, 20]; b := [];

Operatiors: Union + Difference – Intersection * Add Element Include(S, E); Delete Element Exclude(S, E);

Procedure Definition procedure Id[(ArgList)]; const … type … var … begin … end;

Function Definition function Id[(ArgList)]: DataType; const … type … var … begin … Id := Expression; end;

Argument List

[var] VarList: DataType; if no var, call-by-value if var, call-by-variable For example: procedure ConvertRadix(n, Radix: Inte

ger; var R: string);

Exit & Halt

Exit exits the current subroutine, and returns control to the calling routine.

Halt stops program execution, and returns control to the calling program.

Scope For example: program Scope; A, B, C

procedure Alpha; A, F, G procedure Beta; V, B, C

procedure Beta1; F function Beta2; F2

Recursion Recursion means allowing a subroutine to call itsel

f directly or indirectly. For example: function Factorial(n: Integer): Integer; begin if n = 0 then Factorial := 1 else Factorial := n * Factorial(n - 1); end;

Forward Referencing procedure A; forward; procedure B; begin … A; … end; procedure A; begin … B; … end;

Program Task 5

Towers of Hanoi