[Back to FAQ SWAG index] [Back to Main SWAG index] [Original]

    TP 5.5 OOP - OBJECT EXE FILE SIZE OVERHEAD
    Q. How much overhead will result in the *.EXE file from using the
       object oriented style?
    A. The overhead will result from the pointer from the object to
       its method.  This is a 4 byte pointer, so there isn't that
       much extra code generated.

    TP 5.5 OOP - PROTECTED AND PRIVATE FIELDS
    Q. Does Turbo Pascal 5.5 support Protected or Private fields?
    A. No it does not.

    TP 5.5 OOP - RECORDS VS. OBJECTS
    Q. What things can be done with Records that can not be done with
       Objects?
    A. You cannot have:

         1. Variant Objects.
         2. Objects with absolutes.
         3. Directly nested Objects.

       You can have:

           1. Pointers to objects.

    TP 5.5 OOP - EXTERNAL METHODS
    Q. Can methods within an object be external?
    A. Yes. Virtual and Static methods can be written as external
       code. There is no difference between an external Virtual or
       Static method. External Constructors and Destructors are
       difficult to write due to the Prolog and Epilog code within
       them.

    TP 5.5 OOP - CONSTRUCTOR USE
    Q. What are the three purposes of a Constructor?
    A. 1. Insert the address of the VMT into the Object variable.
            (Implicit)
       2. To allocate memory for the Object variable.
            (Implicit)
       3. To initialize the Object variable.
            (Explicit)

    TP 5.5 OOP - DESTRUCTOR HEAP CORRUPTION
    Q. Why is my destructor fragging my heap?
    A. Use:

         Dispose(ptr,done);

       instead of:

         ptr^.done;
         Dispose(done);

    TP 5.5 OOP - SAVING OBJECTS TO DISK
    Q. Can I save my objects to a disk file like I can a record
       structure?
    A. We have provided an example program on the distribution
       diskette, STREAMS, which documents how to save an object to
       disk.

    TP 5.5 OOP - FILES OF OBJECT TYPE
    Q. Why can't I make a file of ObjectType?
    A. Because by the rules of polymorphism, any descendant of
       ObjectType would be type compatible and be able to be written
       to disk as well. The problem with this is that the descendants
       may be (and usually are) of a larger size than the ObjectType
       itself.  Pascal's file structure require all records to be
       the same size, otherwise, how do you know which size object
       do you read in? For an example on how to do Object disk I/O,
       please see the STREAMS example on the distribution diskettes.

    TP 5.5 OOP - SIZEOF OBJECTS CONSTRUCTOR
    Q. Why does Sizeof(MyObject) return a size 2 bytes larger than I
       expect when no virtual methods are used?
    A. By placing a constructor in your object, you're making the
       object virtual.

    TP 5.5 OOP - LINKER STRIPS UNUSED STATIC METHODS
    Q. It appears that my static methods are getting stripped from
       my program by the smart linker when they are unused. Yet,
       my virtual methods are not. How come?
    A. Static methods can be stripped because it can be determined at
       link time what methods will be called. Virtual methods can
       not be stripped because the program will not know what methods
       will be used, and what will not, until run time. This is
       because of late binding.

    TP 5.5 OOP - CONSTRUCTOR CALL TO ANCESTOR WITH VIRTUALS
    Q. If a descendant of a virtual object defines no virtual
       methods of its own, does it need to call the ancestor's
       constructor?
    A. If an object is a descendant of a virtual object, it must call
       that ancestor's constructor or it's own constructor. Even if
       the new object does not define any virtuals of its own. For
       example:

         Type
           A = Object
                 Constructor Init;
                 Procedure AA; Virtual;
           End;
           B = Object ( A )
           End;

       For each instance of A and of B, Init must be called or the
       Virtual Method Table pointer will not be loaded correctly.

    TP 5.5 OOP - OVERRIDE VIRTUAL METHOD CALLING ANCESTOR
    Q. Can I override a virtual method and force a call to the
       ancestor objects method?
    A. No. Late binding will always call the current method and it
       defeats the purpose of object oriented program to go around
       this feature.

    TP 5.5 OOP - CONSTRUCTOR CALL WITHIN METHOD
    Q. I am calling my constructor from within a method, why am I
       having problems?
    A. The problem will arise when the constructor loads the new VMT
       pointer. It loads the pointer to the VMT for the constructor's
       table, not the instances. Therefore if a descendant calls an
       ancestor's constructor, the descendant's VMT will now point to
       the ancestors VMT. The problem now occurs when the descendant
       tries to call a method that was defined after the ancestor.
       The VMT entry for this method is unknown. Look at the
       following example:

         Type
           L1 = Object
                  Constructor Init;
                  Procedure First; Virtual;
           End;
           L2 = Object ( L1 );
                  Constructor Init;
                  Procedure Second; Virtual;
           End;

         Constructor L1.Init;
         Begin
         End;

         Constructor L2.Init;
         Begin
         End;

         Procedure L1.First;
         Begin
           Init;
         End;

         Procedure L2.Second;
         Begin
           Init;
         End;

         Var
           L : L2;

         Begin
           L.Init;   { This calls L2.Init and loads a pointer to }
                     { the L2 VMT into L.                        }
           L.First;  { This will call L1.First, which in turn calls }
                     { L1.Init because as far as the procedure is   }
                     { concerned, the Self pointer is a pointer     }
                     { to an object of type L1.                     }
           L.Second; { This is undefined. Since the VMT now       }
                     { pointed to by L is L1's, the pointer to    }
                     { method Second is undefined. Therefore, the }
                     { call to this method is undefined.          }
           ...

    TP 5.5 OOP - CONSTRUCTOR CALL WITHIN POLYMORPHIC METHOD
    Q. Does the previous question apply to polymorphic procedures?
    A. Yes. The previous question and answer apply to every case
       where the compiler may think of an object as its ancestor. A
       polymorphic example that is incorrect follows:

         Procedure Init ( var x : L1 );
         Begin
           x.Init;  { This will ALWAYS call L1.Init }
         End;

    TP 5.5 OOP - CONSTRUCTOR CALLING ANCESTOR'S CONSTRUCTOR
    Q. Should my current object's constructor call it's ancestor's
       constructors?
    A. As a rule of thumb, this is the correct thing to do. It is
       okay to not do it, but it does allow initialization of
       whatever the previous constructors did.

    TP 5.5 OOP - CALLING ANCESTORS CONSTRUCTOR
    Q. How do you call a constructor from an ancestor's object?
    A. You can call an ancestor's constructor directly from within
       the constructor of the current object.  For example:

         Type
           Type1 = Object
                     Constructor Init;
           End;
           Type2 = Object ( Type1 )
                     Constructor Init;
           End;

         Constructor Type1.Init;
         Begin
         End;

         Constructor Type2.Init;
         Begin
           Type1.Init;
         End;
         ...

[Back to FAQ SWAG index] [Back to Main SWAG index] [Original]