In addition to definitions of public procedures and functions, the implementation section can declare constants, types
(including classes), variables, procedures, and functions that are private to the unit. That is, unlike the interface
section, entities declared in the implementation section are inaccessible to other units.
The implementation section can include its own uses clause, which must appear immediately after the keyword
implementation. The identifiers declared within units specified in the implementation section are only available for
use within the implementation section itself. You cannot refer to such identifiers in the interface section.
The Initialization Section
The initialization section is optional. It begins with the reserved word initialization and continues until the beginning
of the finalization section or, if there is no finalization section, until the end of the unit. The initialization section
contains statements that are executed, in the order in which they appear, on program start-up. So, for example, if
you have defined data structures that need to be initialized, you can do this in the initialization section.
For units in the interfaceuses list, the initialization sections of the units used by a client are executed in the order in
which the units appear in the client's uses clause.
The Finalization Section
The finalization section is optional and can appear only in units that have an initialization section. The finalization
section begins with the reserved word finalization and continues until the end of the unit. It contains statements that
are executed when the main program terminates (unless the Halt procedure is used to terminate the program). Use
the finalization section to free resources that are allocated in the initialization section.
Finalization sections are executed in the opposite order from initialization sections. For example, if your application
initializes units A, B, and C, in that order, it will finalize them in the order C, B, and A.
Once a unit's initialization code starts to execute, the corresponding finalization section is guaranteed to execute
when the application shuts down. The finalization section must therefore be able to handle incompletely initialized
data, since, if a runtime error occurs, the initialization code might not execute completely.
Note: The initialization and finalization sections behave differently when code is compiled for the managed .NET
environment. See the chapter on Memory Management for more information.
Unit References and the Uses Clause
A uses clause lists units used by the program, library, or unit in which the clause appears. A uses clause can occur in
the project file for a program, or library
the interface section of a unit
the implementation section of a unit
Most project files contain a uses clause, as do the interface sections of most units. The implementation section of a
unit can contain its own uses clause as well.
The System unit and the SysInit unit are used automatically by every application and cannot be listed explicitly
in the uses clause. (System implements routines for file I/O, string handling, floating point operations, dynamic
memory allocation, and so forth.) Other standard library units, such as SysUtils, must be explicitly included in the
uses clause. In most cases, all necessary units are placed in the uses clause by the IDE, as you add and remove
units from your project.
In unit declarations and uses clauses, unit names must match the file names in case. In other contexts (such as
qualified identifiers), unit names are case insensitive. To avoid problems with unit references, refer to the unit source
file explicitly:
16