In theory, you can manually call different destructors to free up various external resources, for example, to split the number counting cycles, delete or close a file, etc.
In addition, since the Object Pascal language does not have these new / delete magic operations, there should only be some identifier to call the object.
I would rather look at it retrospectively.
Turbo Pascal with Objects style objects have both, and you call the "magic" Dispose procedure, but you explicitly specify the destructor to call, because the language itself did not know what to choose. Similarly, the "magic" procedure New had to be equipped with a manually selected constructor.
However, this violates the DRY principle: the compiler knows that we call d-tor or c-tor, but still we must additionally call these functions "New" and "Dispose". In theory, it may have been envisaged to separate the allocation of memory and the flow of information, and in any case to combine them. But I do not think that this function was really used as you like.
Interestingly, the same design is used in Apple Objective C. You allocate memory for the object, and after that you call the constructor for this new instance: <a4>
When this model was optimized for Delphi, several decisions were made to make things more simplified (and unified). The memory allocation strategy [de] has been moved to the class level, not to the call site. This made the redundancy of both calls "New" and the named constructor very contrasting. It was necessary to refuse.
C ++ / C # / Java was chosen to store special keywords in the language on it, using overloaded functions to provide various c-tori. Perhaps this is consistent with the American style of computer languages.
However, Pascal has two ideas at its core: verbosity and a little vocabulary. Perhaps they can be traced to other European school languages such as Scala. If possible, keywords should be removed from the language itself and transferred to external modules - libraries that you can add or remove from the project. And overloaded functions were introduced much later into the language, and the early preference was, of course, to have two names, named differently (self-documented).
These two ideas probably caused Delphi to remove the “magic” procedures and deduce the creation / destruction of the object on the call site using only the names of the functions used. If you call MyVar.Destroy , then the compiler looks at the .Destroy and knows that we are deleting the object. It is also known that TMyType.CreateXXX(YYY,ZZZ) is an object instance because CreateXXX was declared.
To make c-tor and d-tor without a name, as in C ++, Delphi would have to enter two more keywords at the language level, for example, C ++ New and delete . And there is no clear advantage. At least I personally like Delphi better.
PS. I had to add one assumption: we are talking about the real languages C ++ and Delphi, as it was in 1995. They displayed only manual memory management for objects allocated by the heap, without garbage collection and automatic recounting. You could not initiate the destruction of the object by assigning the variable a nil / NULL pointer.