Embarcadero Delphi Developer Certification Practice Exam

Correct: B. Object Pascal uses := for assignment and a single = for equality comparison — a defining syntax difference from C-family languages.

Why not the others: == is not a Delphi operator (A, C); using = for assignment (D) is invalid in Pascal. The := / = split is fundamental.

Correct: B — UnicodeString. In modern Delphi the default string is UnicodeString: a reference-counted, dynamically allocated, copy-on-write Unicode string.

Why not the others: ShortString (A) is a legacy fixed-length (max 255) non-reference-counted type; PChar (C) is a pointer to a null-terminated char buffer, not managed; a fixed Char array (D) is static, not a managed string. UnicodeString is the default.

Correct: B. A var parameter is passed by reference, so the routine operates on the caller’s actual variable and any change persists after the call returns.

Why not the others: pass-by-value (A) describes a plain value parameter; read-only (C) describes const; requiring a constant expression (D) is not what var means. var = by reference.

Correct: C. private members are visible only within the same unit, and within that unit protected members are also accessible — Delphi’s visibility is unit-based, which is why "friend" access works inside one unit.

Why not the others: public (A) is accessible everywhere; published (B) is like public but also generates RTTI; automated (D) is a legacy Automation-object specifier. The same-unit rule applies to private/protected.

Correct: B. TInterfacedObject implements reference counting via _AddRef/_Release. When held through interface references, the object is freed automatically once the last reference is released — so you do not call Free manually.

Why not the others: manual Free (A) is for plain objects not held by interface; it does not leak (C); and it is not freed after one call (D). Interface reference counting governs lifetime here.

Correct: B. Delphi generics put the type parameter in angle brackets after the type name: TMyList<T> = class ... end;. You then instantiate it as e.g. TMyList<Integer>.

Why not the others: class of T (A) is a metaclass reference, not a generic; the bracket placement in C and the generic class wording in D are not valid Delphi syntax. The name<T> form is correct.

Correct: B — a TDataSet descendant. Datasets (such as query or table components) represent the set of records in memory; data-aware controls connect to them, typically via a TDataSource, to display and edit data.

Why not the others: TButton (A), TForm (C), and TTimer (D) are UI/utility components with no role as a record container. The dataset is the data abstraction.

Correct: B — Length(s). The RTL function Length returns the number of elements in a string or array — for a string, its character count.

Why not the others: Count (A) is a property on container classes, not a string RTL function; Size (C) and Len (D) are not the Delphi standard routines for this. Length is correct.

Correct: B. The idiomatic pattern is try the work, then finally obj.Free; end; — the finally block runs whether or not an exception is raised, guaranteeing the object is released. Free safely calls the destructor only if the reference is non-nil.

Why not the others: a plain object is not auto-freed (A); calling Destroy directly (C) is unsafe on a nil reference and bypasses the Free guard; assigning nil (D) just drops the reference and leaks the object. try/finally + Free is correct.

Correct: B — try ... finally. The finally block always executes, exception or not, which is exactly what you want for guaranteed cleanup (freeing objects, closing files). try ... except handles exceptions but does not guarantee cleanup on the success path.

Why not the others: try...except (A) catches and handles exceptions rather than guaranteeing cleanup; if (C) and case (D) are ordinary control flow with no exception semantics. Use try/finally for cleanup, try/except to handle.