type 
  TSearchRec = record
                Time : Integer;
                Size : Integer;
                Attr : Integer;
                Name : TFileName;
                ExcludeAttr : Integer;
                FindHandle : THandle;
                FindData : TWin32FindData;
               end;

 Var
    Fichier : File;

Var
  Fichier : File Of Integer;

Var
  Fichier : TextFile;

Type
   TDonnees = Record
                 ValeurEntiere  : Integer;
                 ValeurDecimale : Double;
              End;

Var
   Fichier : File Of TDonnees;

Var
  Donnees : TDonnees;
  Fichier : File Of TDonnees;

Begin
   Donnees.ValeurEntiere := 1298;
   Donnees.ValeurDecimale := 78.123;
   AssignFile(Fichier,'Nom_du_fichier');
   Rewrite(Fichier);
   Write(Fichier,Donnees);
   CloseFile(Fichier);
End;

Type
    TDonnees = Record
                  ValeurEntiere  : Integer;
                  ValeurDecimale : Double;
               End;

Var
  Donnees : TDonnees;
  Fichier : File Of TDonnees;

Begin
   Donnees.ValeurEntiere := 1298;
   Donnees.ValeurDecimale := 78.123;
   AssignFile(Fichier,'Nom_du_fichier');
   Reset(Fichier);
   Read(Fichier,Donnees);
   CloseFile(Fichier);
End;

Type
    // Définition de la structure d'enregistrement
   TDonnees = Record
                 Nom       : String[40];
                 PreNom    : String[40];
                 Adresse   : String[80];
                 Telephone : String[20];
                 Age       : Integer;
              End;

Var
   Donnees    : TDonnees;
   Fichier    : File Of TDonnees;
   NomFichier : String;
   Indice     : Integer;

Var
  Chaine1 : ShortString;// Chaîne de 255 caractères
  Chaine2 : ShortString[100] ;// Chaîne de 100 caractères

Var
   Chaine1 : Array[0..255] Of Char;// ShortString
   Chaine2 : ^Char;     // AnsiString

Var
   Chaine1 : Array[0..255] Of Char;
   Chaine2 : ^Char;     
   C       : Char;

begin
   C := Chaine1[8]; // récupère le huitième caractère de la chaîne
   C := Chaine2[8]; // Provoque une erreur d'exécution avec violation d'adresse.

Var
   Chaine1 : Array[0..255] Of Char;
   Chaine2 : ^Char;     
   C       : Char;

begin
   C := Chaine1[8]; // récupère le huitième caractère de la chaîne
   GetMem(Chaine2,10); // Allouer 10 octets à la variable  
   C := Chaine2[8];

Var
   Chaine1 : String[80];// ShortString de 80 caractères (255 maxi)
   Chaine2 : String;    // AnsiString

begin
   C := Chaine1[8]; // récupère le huitième caractère de la chaîne
   Chaine2 := 'Je vous salut tous';
   C := Chaine2[4]; // C = 'v'

begin
   C := Chaine1[8]; // récupère le huitième caractère de la chaîne
   GetMem(Chaine2,SizeOf('Je vous salut tous'));
   Chaine2 := 'Je vous salut tous';
   C := Chaine2[4]; // C = 'v'

Type
   TChaine = Record
                I : Integer;
                C : String;
             End;

var
  C    : TChaine;
  F    : File Of TChaine;

Type
   TChaine = Record
                I : Integer;
                C : String[60];
             End;

var
  C    : TChaine;
  F    : File Of TChaine;

type
   TF = Record
           Tab : Array Of Array Of Integer;
        End;

Var
   F  : File Of TF;

//---------------------------------------------------------------
Function Copie(Source,Destination : String;Attribus : Integer) : Integer;

Var
   Fd,FS    : File;
   NL,NE    : Integer;
   Buf      : Array[1..100000] Of Byte;

Begin
   Result := -1;
   // Vider éventuellement le tampon d'erreur d'entrée/Sortie
   IoResult;
   // Fixer le mode lecture en lecture seule pour éviter les
   // erreurs de lecture si le fichier est en lecture seule.
   FileMode := 0;
   // Associer le nom du fichier à la variable FD.
   Assignfile(FD,Destination);
   // Créer un fichier en mode écriture avec une taille de base
   // de 1 octet
   Rewrite(FD,1);
   // Associer le nom du fichier à la variable FS.
   AssignFile(FS,Source);
   // Ouvrir un fichier en mode lecture avec une taille de base
   // de 1 octet
   Reset(FS,1);
   Repeat
       Application.ProcessMessages;
       // Lire un paquet de données dans le fichier source
       BlockRead(FS,Buf,SizeOf(Buf),NL);
       // Ecrire dans le destinataire autant de données lues.
       BlockWrite(FD,Buf,NL,NE);
       // Si une erreur est detecté, quitter la fonction.
       If IoResult <> 0 Then Exit;
   Until (NL = 0) Or (NE <> NL);

   CloseFile(FD);
   CloseFile(FS);
   // Fixer les attributs du fichier
   Result := FileSetAttr(Destination,Attribus);
End;
//---------------------------------------------------------------

Procedure Lecture(Nom : String);
Var
   F   : TextFile;
   Chn : String;

Begin
   // Assigner le nom du fichier Nom à la variable F
   AssignFile(F,Nom);
   // Ouvrir le fichier en position zéro.
   Reset(F);
   // Lire le fichier tant que la fin n'est pas atteinte.
   While Not Eof(F) Do
    begin
       ReadLn(F,Chn);
       // Traitement quelconque de la chaîne de caractères Chn.
    
    end;
   // Fermeture du fichier.
   CloseFile(F);
End;

//========================================================

Var
   Tableau  : Array[1..10] Of String;

Procedure Ecriture(Nom : String);
Var
   F   : TextFile;
   Chn : String;

Begin
   // Assigner le nom du fichier Nom à la variable F
   AssignFile(F,Nom);
   // Ouvrir le fichier en position zero.
   Rewrite(F);
   // Lire le fichier tant que la fin n'est pas atteinte.
   For L := 1 To 10 Do
    Begin
       Chn := Tableau[L];
       WriteLn(F,Chn);
    end;
   // Fermeture du fichier.
   CloseFile(F);
End;

Type
    // Définition de la structure d'enregistrement
   TDonnees = Record
                 Nom       : String[40];
                 PreNom    : String[40];
                 Adresse   : String[80];
                 Telephone : String[20];
                 Age       : Integer;
              End;

Var
   Donnees    : TDonnees;
   Fichier    : File Of TDonnees;
   NomFichier : String;
   Indice     : Integer;

//-----------------------------------------------------------------------
Procedure Enregistre(Donnees : TDonnees; Indice : Integer);
Begin
   // Placer le pointeur de fichier à la position "Indice"
   Seek(Fichier,Indice);
   // Ecrire les 188 octets de la variable "Donnees"
   Write(Fichier,Donnees);
End;
//-----------------------------------------------------------------------
Procedure Lecture(Var Donnees : TDonnees; Indice : Integer);
Begin
   // Placer le pointeur de fichier à la position "Indice"
   Seek(Fichier,Indice);
   // Lire 188 octets coresspondants à la variable "Donnees"
   Read(Fichier,Donnees);
End;
//-----------------------------------------------------------------------
Procedure OuvreFichier(Nom : String);
Begin
   AssignFile(Fichier,Nom);
   If Not FileExists(Nom) Then Rewrite(Fichier)
   Else Reset(Fichier);
End;
//-----------------------------------------------------------------------
Procedure FermeFichier;
Begin
   CloseFile(Fichier);
End;

unit Exercice1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Buttons, Menus, Spin;

type
  TFichePrincipale = class(TForm)
    EditNom: TEdit;
    EditPrenom: TEdit;
    EditAdresse: TEdit;
    EditTelephone: TEdit;
    EditAge: TEdit;
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    Label4: TLabel;
    Label5: TLabel;
    MainMenu1: TMainMenu;
    Fichier1: TMenuItem;
    Nouveau1: TMenuItem;
    Ouvrir1: TMenuItem;
    Quitter1: TMenuItem;
    BtPrecedent: TBitBtn;
    BtSuivant: TBitBtn;
    StaticTextIndice: TStaticText;
    Label6: TLabel;
    SpinEdit1: TSpinEdit;
    Label7: TLabel;
    BtValider: TBitBtn;
    OpenDialog1: TOpenDialog;
    SaveDialog1: TSaveDialog;
    StaticTextNbEnr: TStaticText;
    Label8: TLabel;
    BtRecherche: TButton;
    BtAjoute: TBitBtn;
    procedure Nouveau1Click(Sender: TObject);
    procedure Ouvrir1Click(Sender: TObject);
    procedure SpinEdit1KeyPress(Sender: TObject; var Key: Char);
    procedure BtRechercheClick(Sender: TObject);
    procedure BtValiderClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure BtAjouteClick(Sender: TObject);
    procedure BtPrecedentClick(Sender: TObject);
    procedure BtSuivantClick(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
    Procedure ActualiseAffichage;
  end;

var
  FichePrincipale: TFichePrincipale;

implementation

{$R *.DFM}


Type
   TDonnees = Record
                 Nom       : String[40];
                 PreNom    : String[40];
                 Adresse   : String[80];
                 Telephone : String[20];
                 Age       : Integer;
              End;

Var
   Donnees        : TDonnees;
   Fichier        : File Of TDonnees;
   NomFichier     : String;
   TailleFichier,
   NbDonnees,
   Indice         : Integer;




{-------------------------------------------------------------------}
{       Indique si une chaîne de caractères représente une valeur   }
{       entière valide.                                             }
{-------------------------------------------------------------------}
Function ChaineEntierValide(Chn : String) : Boolean;
Var
  I  : Integer;
Begin
   Result:=False;
   If (Length(Chn) = 0) Or (Chn = '-') Then Exit;
   For I:=1 To Length(Chn) Do
    If Not (Chn[I] In['0'..'9']) Then Exit;
   Result:=True;
End;
//-----------------------------------------------------------------------
Procedure Enregistre(Donnees : TDonnees; Indice : Integer);
Begin
   Seek(Fichier,Indice);
   Write(Fichier,Donnees);
   // Forcer l'écriture physique du fichier (Tampon disque -> Disque)
   CloseFile(Fichier);
   Reset(Fichier);
End;
//-----------------------------------------------------------------------
Procedure Lecture(Var Donnees : TDonnees; Indice : Integer);
Begin
   // Placer le pointeur de fichier à la position correspondante.
   Seek(Fichier,Indice);
   // Lire in bloc de données
   Read(Fichier,Donnees);
End;
//-----------------------------------------------------------------------
Procedure OuvreFichier(Nom : String);
Begin
   AssignFile(Fichier,Nom);
// Si le fichier n'existe pas, le créer si non l'ouvrir
   If Not FileExists(Nom) Then Rewrite(Fichier)
   Else Reset(Fichier);
End;
//-----------------------------------------------------------------------
Procedure FermeFichier;
Begin
   CloseFile(Fichier);
End;
//-----------------------------------------------------------------------

procedure TFichePrincipale.FormCreate(Sender: TObject);
begin
   Indice :=0;
end;
//-----------------------------------------------------------------------
procedure TFichePrincipale.FormClose(Sender: TObject; var Action: TCloseAction);
begin
   FermeFichier;
end;

//-----------------------------------------------------------------------
procedure TFichePrincipale.ActualiseAffichage;
begin
   With Donnees Do
    begin
       EditNom.Text := Nom;
       EditPrenom.Text := Prenom;
       EditAdresse.Text := Adresse;
       EditTelephone.Text := Telephone;
       EditAge.Text := IntToStr(Age);
    end;
   StaticTextNbEnr.Caption := IntToStr(NbDonnees);
   SpinEdit1.MaxValue := NbDonnees;
   StaticTextIndice.Caption := IntToStr(Indice + 1);
end;
//-----------------------------------------------------------------------
// Création d'un nouveau fichier.
//-----------------------------------------------------------------------
procedure TFichePrincipale.Nouveau1Click(Sender: TObject);
begin
   If SaveDialog1.Execute Then
    begin
       NomFichier := SaveDialog1.FileName;
       If FileExists(NomFichier) Then
        begin
           If MessageDlg('Le fichier <' + NomFichier + '> existe !' + 
                          #13#10 +
                         'Faut il le remplacer ',
                         mtConfirmation,[mbYes,mbNo],0) = mrNo Then Exit
           Else DeleteFile(NomFichier);
        end;
      OuvreFichier(NomFichier);
      NbDonnees := 0;
    end;
end;
//-----------------------------------------------------------------------
// Ouverture d'un fichier existant.
//-----------------------------------------------------------------------
procedure TFichePrincipale.Ouvrir1Click(Sender: TObject);
begin
   If OpenDialog1.Execute Then
    begin
       NomFichier := OpenDialog1.FileName;
       If Not FileExists(NomFichier) Then
        begin
           If MessageDlg('Le fichier <' + NomFichier + '> n''existe pas !'
                          + #13#10 +
                         'Faut il le créer ?',
                         mtConfirmation,[mbYes,mbNo],0) = mrNo Then Exit;
        end;
       OuvreFichier(NomFichier);

       // FileSize renvoi le nombre d'enregistrements selon son type
       // définit et non pas le nombre d'octets qu'il occupe sur le disque.
       // Le fichier étant du type TDonnees qui fait 184 octet, si le 
       // fichier occupe 184 octets il y a 1 seul enregistrement.
       TailleFichier := FileSize(Fichier);
       If  TailleFichier >= 1 Then
        begin
           NbDonnees := TailleFichier;
           Lecture(Donnees,0);
           SpinEdit1.Value := NbDonnees;
        end;
       ActualiseAffichage;
    end;
end;
//-----------------------------------------------------------------------
// Définition de l'indice de recherché.
//-----------------------------------------------------------------------
procedure TFichePrincipale.SpinEdit1KeyPress(Sender: TObject; var Key: Char);
begin
   // Limiter la saisie aux chiffres. #8 est le code de la touche 
   // d'effacement
   If Not (Key In['0'..'9',#8]) Then Key := #0;
end;
//-----------------------------------------------------------------------
// Rechercher les données d'un élément selon son indice dans le fichier.
//-----------------------------------------------------------------------
procedure TFichePrincipale.BtRechercheClick(Sender: TObject);
Var
   Chn    : String;

begin
   Chn := SpinEdit1.Text;
   If ChaineEntierValide(Chn) Then
    begin
       Indice := SpinEdit1.Value - 1;
       If (Indice <= NbDonnees)  Then
        begin
           Lecture(Donnees,Indice);
           ActualiseAffichage;
        end;
    end;
end;
//-----------------------------------------------------------------------
// Valider les modifications d'un élément de l'agenda.
//-----------------------------------------------------------------------
procedure TFichePrincipale.BtValiderClick(Sender: TObject);
begin
   With Donnees Do
    begin
       Adresse := EditAdresse.Text;
       Nom := EditNom.Text;
       PreNom := EditPrenom.Text;
       Telephone := EditTelephone.Text;
       Age := StrToInt(EditAge.Text);
    end;
   Enregistre(Donnees,Indice);
end;

//-----------------------------------------------------------------------
// Ajouter un élément à l'agenda.
//-----------------------------------------------------------------------
procedure TFichePrincipale.BtAjouteClick(Sender: TObject);
begin
   With Donnees Do
    begin
       Adresse := EditAdresse.Text;
       Nom := EditNom.Text;
       PreNom := EditPrenom.Text;
       Telephone := EditTelephone.Text;
       Age := StrToInt(EditAge.Text);
    end;
   Enregistre(Donnees,TailleFichier);
   TailleFichier := FileSize(Fichier);
   NbDonnees := TailleFichier;
   Indice:=NbDonnees - 1;
   SpinEdit1.Value := NbDonnees;
   ActualiseAffichage;
end;

//-----------------------------------------------------------------------
// Lire l'enregistrement précédent dans le fichier.
//-----------------------------------------------------------------------
procedure TFichePrincipale.BtPrecedentClick(Sender: TObject);
begin
   If  NbDonnees >= 1 Then
    begin
       If Indice > 0 Then
        begin
           Dec(Indice);
           Lecture(Donnees,Indice);
        end;
    end;
   ActualiseAffichage;
end;
//-----------------------------------------------------------------------
// Lire l'enregistrement suivant dans le fichier.
//-----------------------------------------------------------------------
procedure TFichePrincipale.BtSuivantClick(Sender: TObject);
begin
   If  NbDonnees >= 1 Then
    begin
       If Indice < NbDonnees - 1 Then
        begin
           Inc(Indice);
           Lecture(Donnees,Indice);
        end;
    end;
   ActualiseAffichage;
end;
//-----------------------------------------------------------------------

end.

implementation

{$R *.DFM}


Type
   TDonnees = Record
                 Nom       : String[40];
                 PreNom    : String[40];
                 Adresse   : String[80];
                 Telephone : String[20];
                 Age       : Integer;
              End;

Var
   Donnees        : TDonnees;
   FichierBak,     // Identificateur du fichier temporaire
   Fichier        : File Of TDonnees;
   NomFichier     : String;
   TailleFichier,
   NbDonnees,
   Indice         : Integer;

//-----------------------------------------------------------------------
procedure TFichePrincipale.BtSupprimeClick(Sender: TObject);
Var
   I  : Integer;

begin
   // Création d'un fichier temporaire
   AssignFile(FichierBak,'FichierTemp');
   If FileExists('FichierTemp') Then DeleteFile('FichierTemp');
   Rewrite(FichierBak);

   // Copier tous les enregistrements du fichier d'origine à
   // l'exception de l'enregistrement à supprimer
   For I := 0 To NbDonnees - 1 Do
    begin
       If I <> Indice Then
        begin
           Seek(Fichier,I);
           Read(Fichier,Donnees);
           Write(FichierBak,Donnees);
        end;
    end;
   Dec(NbDonnees);

   // Fermer les fichier
   CloseFile(FichierBak);
   CloseFile(Fichier);

   // Supprimer le fichier d'origine
   DeleteFile(NomFichier);

   // Renomer le fichier temporaire avec le nom d'origine
   RenameFile('FichierTemp',NomFichier);

   // Actualliser
   OuvreFichier(NomFichier);
   If NbDonnees > 0 Then
    If Indice > 0 Then
     begin
        Dec(Indice);
        Lecture(Donnees,Indice);
     end;
   ActualiseAffichage;
end;

end.

Type
   TDonnees = Record
                 Nom         : String[40];
                 PreNom      : String[40];
                 Adresse     : String[80];
                 Telephone   : String[20];
                 Age         : Integer;
                 Photo       : Array[0..90054] Of Byte;
                 TaillePhoto : Integer;
              End;

//-----------------------------------------------------------------------
procedure TFichePrincipale.TransfertPhotoDansStructure;
Var
   Flux : TMemoryStream;
   C, T : Integer;
   Buff : ^Byte;

begin
   Flux := TMemoryStream.Create;
   // Transfert de la photo dans le flux
   Image1.Picture.Bitmap.SaveToStream(Flux);
   // Connaitre la taille en octets du flux
   T := Flux.Size;
      // Attribuer un espace mémoire au buffer
   GetMem(Buff,T);
   // Placer le lecteur du flux en position zéro.
   Flux.Position :=0;
   // Transfert des données de la photo dans le tableau
   Flux.Read(Buff^,T);
   Move(Buff^,Donnees.Photo,T);
   // Memorisation de la taille du flux
   Donnees.TaillePhoto := T;
   Flux.Free;
end;
//-----------------------------------------------------------------------
procedure TFichePrincipale.TransfertPhotoDepuisStructure;
Var
   Flux : TMemoryStream;
   T    : Integer;
   Buff : ^Byte;

begin
   Flux := TMemoryStream.Create;
   // A ce stade, le flux n'a pas d'espace réservé. Il faut donc lui
   // atribuer un espace mémoire correspondant à la taille du bitmap.
   T:= Donnees.TaillePhoto;
   Flux.SetSize(T);
   // Transfert des données de la photo depuis le tableau, dans le flux
   GetMem(Buff,T);
   Move(Donnees.Photo,Buff^,T);
   // Replacer le pointeur de flux à la position 0
   Flux.Seek(0,soFromBeginning);
   Flux.Position :=0;
   Flux.Write(Buff^,T);
   // Replacer le pointeur de flux à la position 0
   Flux.Seek(0,soFromBeginning);
   // Transfert du flux dans le bitmap
   Image1.Picture.BitMap.LoadFromStream(Flux);
   Image1.Refresh;
   Flux.Free;
end;
//-----------------------------------------------------------------------
// Ouverture du fichier BitMap pour la photo d'identité
procedure TFichePrincipale.BtPhotoClick(Sender: TObject);
Var
   Nom  : String;

begin
   If OpenPictureDialog1.Execute Then
    begin
       Nom := OpenPictureDialog1.FileName;
       // Attention, il n'y a pas de sécurité pour la dimension de l'image
       Image1.Picture.LoadFromFile(Nom);
    end;
end;
//-----------------------------------------------------------------------

Type
   TDonnees = Record
                 Nom         : String[40];
                 PreNom      : String[40];
                 Adresse     : String[80];
                 Telephone   : String[20];
                 Age         : Integer;
                 Photo       : Array[0..90053] Of Byte;
                 TaillePhoto : Integer;
                 Commentaire : ShortString; // 255 caractères maxi
              End;

//-----------------------------------------------------------------------
procedure TFichePrincipale.ActualiseAffichage;
Var
  Chn : String;

begin
   With Donnees Do
    begin
       EditNom.Text := Nom;
       EditPrenom.Text := Prenom;
       EditAdresse.Text := Adresse;
       EditTelephone.Text := Telephone;
       EditAge.Text := IntToStr(Age);
       TransfertPhotoDepuisStructure;
       Chn := Commentaire;
    end;
   // Vérification si la chaîne commentaire contient un texte et
   // ajout dans le mémo.
   If Chn <> '' Then Memo1.Lines.SetText(PChar(Chn));

   StaticTextNbEnr.Caption := IntToStr(NbDonnees);
   SpinEdit1.MaxValue := NbDonnees;
   StaticTextIndice.Caption := IntToStr(Indice + 1);
end;
//-----------------------------------------------------------------------
procedure TFichePrincipale.BtValiderClick(Sender: TObject);
Var
   Chn  : String;
   L, I : Integer;
begin
   L := Memo1.Lines.Count;
   Chn := '';
// Si le Memo contient un texte, ajouter ce texte dans l'enregistrement.
   If L > 0 Then
    Begin
       // Copier le contenu du memo dans la chaine de caractères.
       For I:=0 To L-1 Do Chn := Chn + Memo1.Lines[I];
    end;


   With Donnees Do
    begin
       Adresse := EditAdresse.Text;
       Nom := EditNom.Text;
       PreNom := EditPrenom.Text;
       Telephone := EditTelephone.Text;
       Age := StrToInt(EditAge.Text);
       TransfertPhotoDansStructure;
       Commentaire := Chn;
    end;
   // Enregistrer les données dans le fichier.
   Enregistre(Donnees,Indice);
end;
//-----------------------------------------------------------------id="XV"------

Type

TTri = Record
              Index   : Integer;
              Nom     : String[40];
           End;


Var
   TableNoms      : Array Of TTri;

//-----------------------------------------------------------------------
Procedure ChargeNomsAgenda;
Var
  I  : Integer;

Begin