Les possibles évolutions du langage Delphi sous Delphi 2005

Date de publication : 09/10/2004 , Date de mise a jour : 15/10/2004

Par Laurent Dardenne (home page)
 

Pour une présentation de Delphi 2005, vous pouvez consulter l'article de Pierre Castelain.
Cet article présente les évolutions du langage Delphi sous Delphi 2005.
Il s'agit bien sur de possible évolutions étant donné qu'à ce jour, début octobre 2004, le produit n'est pas encore finalisé.
Sous réserve de ma traduction de l'aide en ligne de Delphi 2005.

1. Convention d'appel INLINE

procedure MyProc(x:Integer); inline;
begin
    // ...
end;

function MyFunc(y:Char) : String; inline;
begin 
   // ..
end;

• les routines contenant de l'assembleur.
• les constructeurs et les destructeurs.
• le bloc de programme principal, d'initialisation et de finalisation d'unité.
• les routines qui utilisent des tableaux ouverts comme paramètres.
• ...

2. Déclarations imbriquées

2.1. Déclaration de types imbriqués

type
  className = class [abstract | sealed] (ancestorType)
      memberList
      type
         DeclarationDeTypeImbriqué
        memberList
  end;

2.1.1. Déclarer et accèder aux classes imbriqués

type
   TClassConteneur = class
     strict private
       myField: Integer;
 
      public
        type     // Début de déclaration de la classe imbriquée
            TClassImbriquee = class
             public
               monChampImbrique: Integer;
               procedure ProcImbrique;
            end; // Fin de déclaration de la classe imbriquée

       procedure ProcConteneur; // Ici prend fin de déclaration du type imbriqué
    end;

procedure TClassConteneur.TClassImbriquee.innerProc;
begin
   ...
end;

var
   x: TClassConteneur;
   y: TClassConteneur.TClassImbriquee;

begin
   x := TClassConteneur.Create;
   x.ProcConteneur;
   ...
   y := TClassConteneur.TClassImbriquee.Create;
   y.ProcImbrique;

2.2. Déclarations de constantes imbriquées

type
   TMyClass = class
        const
             x = 12;
             y = TMyClass.x + 23;
        procedure Hello;
        private
             const
                 s = 'A string constant';
    end;
 
begin
   writeln(TMyClass.y);   // Writes the value of y, 35.
end.

3. Itération sur des conteneurs et des classes

3.1. Rappel de l’instruction For

for compteur := Valeurinitiale to ValeurFinale do instructions

for compteur := Valeurinitiale downto ValeurFinale do instructions

• compteur est une variable locale (declarée dans le bloc contenant l’instruction for) de type ordinal, sans aucun qualifificateur.
• ValeurInitiale et ValeurFinale sont des expressions compatible avec une assignation de compteur ( type scalaire).
• Instructions est une instruction simple ou structurée qui ne modifie pas la valeur du compteur.

3.2. Itération sur des conteneurs

• for Element in ArrayExpression do Instruction;
• for Element in StringExpression do Instruction;
• for Element in SetExpression do Instruction;
• for Element in CollectionExpression do Instruction;

type
  TIntArray        = array[0..9] of Integer;
  TGenericIntArray = array of Integer;

var
  IArray1: array[0..9] of Integer   = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  IArray2: array[1..10] of Integer  = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  IArray3: array[1..2] of TIntArray = ((11, 12, 13, 14, 15, 16, 17, 18, 19, 20),
                                       (21, 22, 23, 24, 25, 26, 27, 28, 29, 30));
  MultiDimTemp: TIntArray;
  IDynArray:    TGenericIntArray;

  I: Integer;

begin
  for I in IArray1 do 
     begin 
         // Fait qq chose avec I...
     end;

  // L'indexation commence à 1, la limite de rangée inférieure.
  for I in IArray2 do
     begin
         // Fait qq chose avec I...
     end;

  // Itération sur un tableau multi-dimensionnel
  for MultiDimTemp in IArray3 do   // indexation 1..2
    for I in MultiDimTemp do       // indexation 0..9
      begin
          // Fait qq chose avec I...
      end;

  // Itération sur un tableau dynamique
  IDynArray := IArray1;
  for I in IDynArray do
     begin
        // Fait qq chose avec I...
     end;

var
  C: Char;
  S1, S2: String;
  Counter: Integer;

  OS1, OS2: ShortString;
  AC: AnsiChar;
  
begin

  S1 := 'Now is the time for all good men to come to the aid of their country.';
  S2 := '';

  for C in S1 do
    S2 := S2 + C;

  if S1 = S2 then
    WriteLn('SUCCESS #1');
  else
    WriteLn('FAIL #1');

  OS1 := 'When in the course of human events it becomes necessary to dissolve...';
  OS2 := '';

  for AC in OS1 do
    OS2 := OS2 + AC;

  if OS1 = OS2 then
    WriteLn('SUCCESS #2');
  else
    WriteLn('FAIL #2');
end.

type

  TMyThing = (one, two, three);
  TMySet   = set of TMyThing;
  TCharSet = set of Char;

var
  MySet:   TMySet;
  MyThing: TMyThing;

  CharSet: TCharSet;
  {$IF DEFINED(CLR)} // Indique si on compile pour DOT NET 
  C: AnsiChar;
  {$ELSE}
  C: Char;
  {$IFEND}

begin

  MySet := [one, two, three];
  for MyThing in MySet do
   begin
    // Fait qq chose avec MyThing...
   end;


  CharSet := [#0..#255];
  for C in CharSet do
    begin
      // Fait qq chose avec C...
    end;
end.

3.3. Itération sur des classes

• La classe doit posséder une méthode publique d'instance appelée GetEnumerator(). La méthode GetEnumerator() doit renvoyer une classe, une interface, ou un type record.
• La classe, l'interface, ou le record renvoyé par GetEnumerator() doit contenir une méthode d'instance publique appelée MoveNext(). La méthode MoveNext() doit renvoyer un booléen.
• La classe, l'interface, ou le record renvoyé par GetEnumerator() doit contenir une propriété publique en lecture seule appelée Current. Le type de la propriété Current doit être du même type que celui contenu dans la collection.

type
  TMyIntArray = array of Integer;

  TMyEnumerator = class
    Values: TMyIntArray;
    Indice:  Integer;
  public
    constructor Create;
    function GetCurrent: Integer;
    function MoveNext:   Boolean;
    property Current:    Integer read GetCurrent;
  end;

  TMyContainer  = class
  public
   function GetEnumerator: TMyEnumerator;
  end;

constructor TMyEnumerator.Create;
begin
  inherited Create;
  Values := TMyIntArray.Create(100, 200, 300);
  Indice := -1;
end;

function TMyEnumerator.MoveNext: Boolean;
begin
  if Indice < High(Values) then
    begin
      Inc(Indice);
      Result := True;
    end
  else
    Result := False;
end;

function TMyEnumerator.GetCurrent: Integer;
begin
  Result := Values[Indice];
end;

function TMyContainer.GetEnumerator: TMyThing;
begin
  Result := TMyEnumerator.Create;
end;

var
  MyContainer: TMyContainer;
  I: Integer;

  Counter: Integer;

begin
  MyContainer := TMyContainer.Create;

  Counter := 0;
  for I in MyContainer do
    Inc(Counter, I);

  WriteLn('Counter = ', Counter);
end.

• TList
• TCollection
• TStrings
• TInterfaceList
• TComponent
• TMenuItem
• TCustomActionList
• TFields
• TListItems
• TTreeNodes
• TToolBar

4. Les directives de compilations

4.1. MESSAGE

 {$MESSAGE 'Boo!'}                   émet un conseil (hint)
 {$Message Hint 'Feed the cats'}     émet un conseil (hint)
 {$messaGe Warn 'Looks like rain.'}  émet un avertissement ( warning )
 {$Message Error 'Not implemented'}  émet une erreur,la compilation continue
 {$Message Fatal 'Bang.  Yer dead.'} émits une erreur,la compilation prend fin

4.2. REALCOMPATIBILITY

4.3. UNSAFE

{$UNSAFECODE ON} ou {$UNSAFECODE OFF}

procedure unsafeProc; unsafe;
begin
end;

4.4. NODEFINE

{$NODEFINE Identifieur}

type
    Temperature = type double;
    {$NODEFINE Temperature}
    {$HPPEMIT 'typedef double Temperature'}

4.5. NOINCLUDE

{$NOINCLUDE NomDeFichier}