Quick start manual

7-14 Delphi Language Guide
Methods
parameters to the constructor. Finally, the constructor returns a reference to the
newly allocated and initialized object. The type of the returned value is the same as
the class type specified in the constructor call.
If an exception is raised during execution of a constructor that was invoked on a class
reference, the Destroy destructor is automatically called to destroy the unfinished
object.
When a constructor is called using an object reference (rather than a class reference),
it does not create an object. Instead, the constructor operates on the specified object,
executing only the statements in the constructor’s implementation, and then returns
a reference to the object. A constructor is typically invoked on an object reference in
conjunction with the reserved word inherited to execute an inherited constructor.
Here is an example of a class type and its constructor.
type
TShape = class(TGraphicControl)
private
FPen: TPen;
FBrush: TBrush;
procedure PenChanged(Sender: TObject);
procedure BrushChanged(Sender: TObject);
public
constructor Create(Owner: TComponent); override;
destructor Destroy; override;
ƒ
end;
constructor TShape.Create(Owner: TComponent);
begin
inherited Create(Owner); // Initialize inherited parts
Width := 65; // Change inherited properties
Height := 65;
FPen := TPen.Create; // Initialize new fields
FPen.OnChange := PenChanged;
FBrush := TBrush.Create;
FBrush.OnChange := BrushChanged;
end;
The first action of a constructor is usually to call an inherited constructor to initialize
the object’s inherited fields. The constructor then initializes the fields introduced in
the descendant class. Because a constructor always clears the storage it allocates for a
new object, all fields start with a value of zero (ordinal types), nil (pointer and class
types), empty (string types), or Unassigned (variants). Hence there is no need to
initialize fields in a constructor’s implementation except to nonzero or nonempty
values.
When invoked through a class-type identifier, a constructor declared as virtual is
equivalent to a static constructor. When combined with class-reference types,
however, virtual constructors allow polymorphic construction of objects—that is,
construction of objects whose types aren’t known at compile time. (See “Class
references” on page 7-24.)