home *** CD-ROM | disk | FTP | other *** search
/ CD Shareware Magazine 1996 December / CD_shareware_12-96.iso / DOS / Programa / TI2957.ZIP / TI2957.ASC < prev   
Encoding:
Text File  |  1996-05-21  |  7.7 KB  |  221 lines
  1.    NUMBER  :  2957
  2.   PRODUCT  :  Delphi
  3.   VERSION  :  2.0
  4.        OS  :  Win32
  5.      DATE  :  May 21, 1996                            
  6.  
  7.     TITLE  :  New Language Features in Delphi 2.0
  8.  
  9. New Language Features in Delphi 2.0 - 32
  10.  
  11. Delphi 2.0 defines several new data types that exploit the 
  12. features available by Windows 95.  Delphi 2.0 has also changed 
  13. a few data types to take advantage of the 32-bit environment.  
  14.  
  15. New data types include:
  16.  
  17.    Character type
  18.    String type
  19.    Variant type
  20.    Currency type
  21.  
  22. Changed data types:
  23.  
  24.    Integer
  25.    Cardinal
  26.  
  27. Additional Syntax:
  28.  
  29.    Unit finalization section
  30.      
  31.  
  32. New Data Types
  33. --- ---- -----
  34.  
  35. Character Type
  36.  
  37. Delphi 2.0 introduces new wide character types to support 
  38. Unicode.  Delphi 1.0 treated characters as 8-bit values of type 
  39. Char.
  40.  
  41. These are the standard types that represent characters in 
  42. Delphi 2.0.
  43.  
  44.    ANSIChar - A standard 8-bit ANSI character, equivalent to the 
  45.               Char type in previous versions of Delphi.
  46.  
  47.    WideChar - A 16-bit character, representing a Unicode 
  48.               character.  If the high-order byte is zero, the 
  49.           low-order byte contains an ANSI character.
  50.  
  51.        Char - By default, Char is equivalent to ANSIChar.  Char 
  52.               works in the same way as the 
  53.           implementation-dependent Integer type, which is 
  54.               equivalent to SmallInt in 16-bit versions of Delphi 
  55.           and to LongInt in 32-bit versions of Delphi.  In 
  56.               Delphi 2.0, Char defaults to an 8-bit value.  
  57.  
  58. Character-pointer types:
  59.  
  60.               Pointer type    Character type
  61.               -----------------------------------
  62.               PANSIChar        ANSIChar
  63.           PWideChar        WideChar
  64.               PChar        Char
  65.  
  66.           The semantics of all the character-pointer types 
  67.               are identical.  The only thing that varies is the 
  68.               size of the character pointed to.
  69.  
  70. String Type
  71.  
  72. Delphi 2.0 supports strings of nearly unlimited length in 
  73. addition to the 255-character counted strings previously 
  74. supported.  A new compiler directive, $H, controls whether the 
  75. reserved word "string" represents a short string or the new, 
  76. long string.  The default state of $H, is $H+, using long 
  77. strings by default.  All Delphi 2.0 components use the new long
  78. string type.
  79.  
  80. These are the new string types.
  81.  
  82.    ShortString - A counted string with a maximum length of 255
  83.                  characters.  Equivalent to String in 
  84.                  Delphi 1.0. Each element is of type ANSIChar.
  85.     AnsiString - A new-style string of variable length, also 
  86.          called a "long string."  Each element is of 
  87.          type ANSIChar.
  88.         string - Either a short string or an ANSI string, 
  89.                  depending on the value of the $H compiler 
  90.          directive.
  91.  
  92.  
  93. Here are the compatibility issues.
  94.  
  95. Although most string code works interchangeably between short 
  96. strings and long strings, there are certain short-string 
  97. operations that either won't work on long strings at all or 
  98. which operate more efficiently when done a different way.  The 
  99. following table summarizes these changes.
  100.  
  101. Short String     Long string
  102. operation    equivalent      Explanation
  103. ----------------------------------------------------------------
  104. PString type    string              All long strings are 
  105.                                   dynamically allocated, so 
  106.                                   PString is redundant and 
  107.                   requires more bookkeeping.    
  108. S[0] := L    SetLength(S,L)    Because long strings are 
  109.                 SetString(S,P,L)  dynamically allocated, you  
  110.                   must call the SetLength  
  111.                   procedure to allocate the  
  112.                                   appropriate amount of memory.
  113. StrPCopy        StrPCopy(Buffer,
  114. (Buffer, S)    PChar(S))      You can typecast long strings 
  115.                   into null-terminated strings. 
  116.                   The  address of the long  
  117.                   string is the address of its  
  118.                   first character, and the long  
  119.                                   string is followed by a null.
  120. S := StrPas(P)    S := P              Long strings can automatically  
  121.                                   copy from null-terminated 
  122.                   strings.
  123.  
  124. Long strings cannot be passed to OpenString-type parameters or 
  125. var short-string parameters.
  126.  
  127. Variant Type
  128.  
  129. Delphi 2.0 introduces variant types to give you the flexibility
  130. to dynamically change the type of a variable. This is useful 
  131. when implementing OLE automation or certain kinds of database 
  132. operations where the parameter types on the server are unknown 
  133. to your Delphi-built client application.
  134.  
  135. A variant type is a 16-byte structure that has type 
  136. information embedded in it along with its value, which can 
  137. represent a string, integer, or floating-point value. The 
  138. compiler recognizes the standard type identifier Variant as the 
  139. declaration of a variant.
  140.  
  141. In cases where the type of a variant is incompatible with the 
  142. type needed to complete an operation, the variant will 
  143. automatically promote its value to a compatible value, if 
  144. possible. For instance, if a variant contains an integer and 
  145. you assign it to a string, the variant converts its value into 
  146. the string representing the integer number, which is then 
  147. assigned to the string.
  148.  
  149. You can also assign a variant expression to a variable of a 
  150. standard type or pass the variant as a parameter to a routine 
  151. that expects a standard type as a parameter. Delphi coerces the 
  152. variant value into a compatible type if necessary, and raises 
  153. an exception if it cannot create a compatible value.
  154.  
  155. Currency Type
  156.  
  157. Delphi 2.0 defines a new type called Currency, which is a 
  158. floating-point type specifically designed to handle large 
  159. values with great precision. Currency is assignment-compatible 
  160. with all other floating-point types (and variant types), but 
  161. is actually stored in a 64-bit integer value much like the Comp 
  162. type.
  163.  
  164. Currency-type values have a four-decimal-place precision. That 
  165. is, the floating-point value is stored in the integer format 
  166. with the four least significant digits implicitly representing 
  167. four decimal places.
  168.  
  169.  
  170. Changed Data Types
  171. ------- ---- -----
  172. The implementation-dependent types Integer and Cardinal are 
  173. 32-bit values in Delphi 2.0, where they were 16-bit values in 
  174. Delphi 1.0. To explicitly declare 16-bit integer data types, 
  175. use the SmallInt and Word types.
  176.  
  177. Additional Syntax
  178. ---------- ------
  179. You can include an optional finalization section in a unit. 
  180. Finalization is the counterpart of initialization, and takes 
  181. place when the application shuts down. You can think of the 
  182. finalization section as "exit code" for a unit. The 
  183. finalization section corresponds to calls to ExitProc and 
  184. AddExitProc in Delphi 1.0.
  185.  
  186. The finalization begins with the reserved word finalization. 
  187. The finalization section must appear after the initialization 
  188. section, but before the final end. statement.
  189.  
  190. Once execution enters an initialization section of a unit, 
  191. the corresponding finalization section is guaranteed to 
  192. execute when the application shuts down. Finalization sections 
  193. must handle partially-initialized data properly, just as class 
  194. destructors must.
  195.  
  196. Finalization sections execute in the opposite order that units 
  197. were initialized. For example, if your application initializes 
  198. units A, B, and C, in that order, it will finalize them in the 
  199. order C, B, and A.
  200.  
  201. The outline for a unit therefore looks like this:
  202.  
  203. unit UnitName;
  204. interface
  205. { uses clause; optional }
  206. ...
  207. implementation
  208. { uses clause; optional }
  209. ...
  210. initialization { optional }
  211. ...
  212. finalization { optional }
  213. ...
  214. end.
  215.  
  216.  
  217. DISCLAIMER: You have the right to use this technical information
  218. subject to the terms of the No-Nonsense License Statement that
  219. you received with the Borland product to which this information
  220. pertains.
  221.