# ATELIER PROFESSIONNEL DELPHI [OCT-NOV 2003] --- SUPPORT DE COURS # # JOUR 2 : TYPES DE DONNEES UTILISATEUR, STRUCTURES DE CONTROLES, ROUTINES # ---------------------------------------------------------------------------- Rappels de base sur le code ---------------------------------------------------------------------------- Votre application doit être en console : {$APPTYPE CONSOLE} N'oubliez pas un éventuel ReadLn; en fin de programme pour y voir quelque chose, sauf évidemment si vous avez un interpréteur de commandes d'ouvert... Indentation : 4 espaces. On indente dans les blocs, sous les structures de contrôle et les sections de déclaration, etc. Les opérateurs and et or servant aussi bien en bit-à-bit qu'en booléen, leur priorité est souvent foireuse. Parenthéser pour ne laisser aucun doute. Sorties de flux : - Boucle : Break / Continue - Routine : Exit - Programme : ça va pas, non ?! ---------------------------------------------------------------------------- Manipulation d'énumérations ---------------------------------------------------------------------------- Déclaration type TRoomOption = (roTV, roChampagne, roJacuzzi); var Option: TRoomOption; Indexation d'un tableau par une énumération type TOptionNames = array[TRoomOption] of string; // Contient 4 strings const OPTION_NAMES: TOptionNames = ('TV', 'Mini-Bar', 'Jacuzzi', 'Escort'); Itération sur l'ensemble des valeurs for Option := Low(TRoomOption) to High(TRoomOption) do // Code qui utilise Option... Par exemple : WriteLn(OPTION_NAMES[Option]); ---------------------------------------------------------------------------- Manipulation d'ensembles ---------------------------------------------------------------------------- Déclaration (basée sur l'énumération) type TRoomOption = (roTV, roChampagne, roJacuzzi); TRoomOptions = set of TRoomOption; var Options: TRoomOptions; Ensemble vide Options := []; Ensemble non vide (ex.) Options := [roTV, roChampagne]; Ajout d'un ensemble à un autre Options := Options + [roChampagne, roJacuzzi]; --ou-- Include(Options, roChampagne); Include(Options, roEscort); Extraction d'un ensemble dans un autre Options := Options - [roJacuzzi]; --ou-- Exclude(Options, roJacuzzi); Présence d'un élément if roTV in Options then... Intersection d'un ensemble (1 élément parmi n) if Options * [roTV, roChampagne] <> [] then... Intersection d'un ensemble (n éléments) if Options * [roTV, roChampagne] = [roTV, roChampagne] then... Examen d'un ensemble basé sur 1'énumération var Option: TRoomOption; Options: TRoomOptions; begin // Options est manipulé, on y met des options... Puis : for Option := Low(TRoomOption) to High(TRoomOption) do if Option in Options then // Code qui va bien... ---------------------------------------------------------------------------- Enregistrements ---------------------------------------------------------------------------- Déclaration type TRoom = record Id: Integer; Booked: Boolean; CustomerName: string; BedSize: TBedSize; // Une énum de tailles de lit Options: TRoomOptions; // Un ensemble d'options possibles end; var Room: TRoom; Utilisation ("Subscripting") Room.Id := 42; Room.Booked := True; Room.CustomerName := 'TDD'; Room.BedSize := bsQueen; Room.Options := [roTV, roChampagne, roJacuzzi]; Le "with" : with Room do begin Id := 42; Booked := True; CustomerName := 'TDD'; BedSize := bsQueen; Options := [roTV, roChampagne, roJacuzzi]; end; ---------------------------------------------------------------------------- Déclarations de routines ---------------------------------------------------------------------------- Procédure procedure SomeProc; // Les éventuelles déclarations (const, var, routines locales)... begin // Le code qui va bien... end; Fonction function SomeFunc: TypeRetour; // Déclarations... begin // Le code qui va bien. Variable "Result" typée TypeRetour // disponible automatiquement et manipulable tout du long. // Pour sortir abruptement : Exit; end; Exemple de réécriture de Pos avec arguments et variables locales : function IndexOf(const Needle, Haystack: string): Integer; var MaxPos, Len: Integer; begin Result := 1; Len := Length(Needle); MaxPos := Length(Haystack) - Len + 1; while Result <= Pos do begin if Copy(Haystack, Result, Len) = Needle then Exit; Inc(Result); end; Result := 0; end; Modes de passage d'argument - Par copie : aucun spécificateur - Par référence modifiable : "var" - Par référence constante : "const" Règles de rédaction de listes d'arguments : - On ouvre une nouvelle section si on change - de mode de passage (copie/référence/référence constante) - de type - Chaque fois que possible, on préfère passer les arguments lourds (structures, tableaux...) par référence constante. Si ils doivent être modifiés, par référence simple. Jamais par copie. ---------------------------------------------------------------------------- Désactivation des contrôles E/S ---------------------------------------------------------------------------- {$I-} ReadLn(VariableEntiere); {$I+} if IOResult <> 0 then // Aïe ! Pas un entier ! Code de traitement ici... ---------------------------------------------------------------------------- Routines standard utiles ---------------------------------------------------------------------------- procedure Randomize function Random(BorneSuperieureOuverte: Integer): Integer procedure ReadLn(LaVariableEntiereOuCharOuStringQuiVaBien) procedure WriteLn(ToutCeQuOnVeutSéparéParDesVirgules) function UpCase(C: Char): Char function Format(const Pattern: string; const Args: array of const): string; procedure Inc(UnScalaire) procedure Dec(UnScalaire) -- Fin de Support de cours --