|
|
|
|
|
|
|
|
|
|
- Overview of an object
- Syntax for declaring/instantiating an object
- Declaring/Instantiating an object
- Declaring/Instantiating a Null object
- Note: Object in progress
- Members and methods
- Lifespan of an object
- Reference on a local object
- Returning an object
- Objects in the loops
- Freeing the object
To access a class, the object must be declared as being part of the class to handle, this is called object instantiation. An instance is an object that belongs to a given class. To handle an object, you must: - Describe the class.
- Instantiate the object.
An object can be passed as parameter to a function or to a procedure. Remark: It is possible to dynamically instantiate an object to a. The implementation of polymorphism requires the dynamic instantiation. For more details, see Dynamic instantiation. Example object: "SourceFile" is an object of class "File".. For this object, you have the ability to handle the members named "Name", "Extension", etc. SourceFile is File object
SourceFile is File
Syntax for declaring/instantiating an object Declaring/Instantiating an object <ObjectName> is [object] <Class Name> ([<Parameters>]) Details of syntax <ObjectName> Name that identifies the instance of the class. <Class Name> Name that identifies the class, defined when creating the class in the code editor. <Parameters> Declaring/Instantiating a Null object <ObjectName> is [object] <Class Name> ([<Parameters>]) = NULL This syntax is used to declare an object without instantiating it. In this case: - the <- operator is used to take a reference on the object.
- the declared variable behaves as if the declaration were non-dynamic: the = operator copies the members.
- the object handled can be returned as return value of the procedure or method.
- in some advanced cases, the object handled can be destroyed to anticipate the automatic destroy operation.
Note: Object in progress The Object keyword can also be used to identify the current object. You can also use the This keyword to access the current object. Reference on a local object The object is created during its declaration. The object is local by default. The local objects are not automatically destroyed at the end of the process execution. Only the local reference is freed. Therefore, if another reference was taken on the object, the object will not be destroyed when the local reference is freed. Example: // Declaration code of global variables
gpo is Class1 dynamic
gArr is array of Class1 dynamic
// Any code
o1, o2, o3 are Class1
gpo1 = o1
Add(gArr, o2)
// At the end of process
// o1 is not destroyed because it is referenced by the global variable gpo
// o2 is not destroyed because it was added to the gArr array
// o3 is not destroyed because there is only the local reference
Returning an object You have the ability to return an object handled by a dynamic or non-dynamic local variable. Remark: In previous versions, it was only possible to return an object manipulated by a dynamic local variable. Objects in the loops In a loop, the objects can be handled by non-dynamic local variables and without explicit allocation. The objects declared in a loop are reallocated at each iteration of the loop and the reference on the object of the previous iteration is freed: - if no other reference was taken, the object is destroyed.
- if a reference was taken (global variable, addition to an array, and so on), the object is not destroyed.
Example: // build the array
t is array of Class1 dynamic
FOR I = 1 TO 10
// create an object corresponding to the subscript
o is Class (x)
o.m_nIndex = i
// add the object into the array
Add(t,o)
END
Freeing the object The objects used by non-dynamic local variables can be explicitly destroyed by the DELETE keyword to anticipate the automatic destruction. Remark: This is an advanced syntax to be used only in very specific cases.. In most cases, the destroy operation is automatic. Reminder As a general rule, there is no need to use the keyword LIBERER. The WLanguage automatically destroys the objects that are no longer used by any variable. The most common cases are: - destroying a set of objects that are referenced in a cyclical way
- freeing the resources used by the instance (sockets, files, ...) in advance via the execution of the destructor.
This page is also available for…
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|