Exercices corrigés Pascal

Exercices corrigés PascalConsultez toutes les sources

Nombre d'auteurs : 3, nombre de sources : 49, dernière mise à jour : 6 mars 2008

Sommaire→Objets

Création d'un objet simple : une personne
Définition des méthodes d'un objet
Exemple d'héritage
Pointeurs d'objets
Liste chaînées d'objets
Polymorphisme

Version hors-ligne

Création d'un objet simple : une personne

On décide de reprendre l'annuaire téléphonique pour le compléter. On déclare ainsi un objet TPersonne, reprenant les caractéristiques des personnes classées dans l'annuaire. Cet objet TPersonne héritera de TObject, afin de profiter des avantages offerts par l'objet TObject. On déclare également un constructeur et un destructeur pour cet objet TPersonne. Créer ensuite quelques instances de TPersonne en lisant les valeurs obtenues au clavier.

objets1.pas

Cacher/Afficher le codeSélectionnez

uses Objects;
 
type
  TPersonne = object(TObject)
    nom, prenom: string;
    age: Integer;
    constructor Init(_nom, _prenom: string; _age: Integer);
  end;
 
constructor TPersonne.Init(_nom, _prenom: string; _age: Integer);
begin
  if not inherited Init then
    Fail;
  nom := _nom;
  prenom := _prenom;
  age := _age;
end;
 
var
  personnes: array[1..10] of TPersonne;
  i, nombrePersonnes: Integer;
  nom, prenom: string;
  age: Integer;
 
begin
  Write('Combien de personnes dans votre annuaire (Maximum : 10) : ');
  ReadLn(nombrePersonnes);
  if nombrePersonnes > 10 then
    nombrePersonnes := 10;
  for i := 1 to nombrePersonnes do
  begin
    Write('Votre nom : ');
    ReadLn(nom);
    Write('Votre prénom : ');
    ReadLn(prenom);
    Write('Votre age : ');
    ReadLn(age);
    personnes[i].Init(nom, prenom, age);
  end;
 
  for i := 1 to nombrePersonnes do
    WriteLn('Nom : ', personnes[i].nom, '  Prénom : ', personnes[i].prenom,
      '  Age : ', personnes[i].age);
  ReadLn;
 
  for i := 1 to nombrePersonnes do
    personnes[i].Done;
 
end.

Créé le 21 juillet 2004 par Mathieu Dalbin

Définition des méthodes d'un objet

On décide de classer les attributs de l'objet TPersonne en attributs privés, tout en gardant dans la clause public les méthodes de l'objet. Ecrire la série de méthodes permettant de lire la valeur des attributs (accesseurs en lecture) et de les modifier (accesseurs en écriture).

objets2.pas

Cacher/Afficher le codeSélectionnez

uses Objects;
 
type
  TPersonne = object(TObject)
  private
    nom, prenom: string;
    age: integer;
  public
    constructor Init;
    procedure setNom(_nom: string); virtual;
    procedure setPrenom(_prenom: string); virtual;
    procedure setAge(_age: integer); virtual;
    function getNom: string; virtual;
    function getPrenom: string; virtual;
    function getAge: integer; virtual;
    destructor Done; virtual;
  end;
 
constructor TPersonne.Init;
begin
  if not inherited Init then
    Fail;
end;
 
procedure TPersonne.setNom(_nom: string);
begin
  nom := _nom;
end;
 
procedure TPersonne.setPrenom(_prenom: string);
begin
  prenom := _prenom;
end;
 
procedure TPersonne.setAge(_age: integer);
begin
  age := _age;
end;
 
function TPersonne.getNom: string;
begin
  getNom := nom;
end;
 
function TPersonne.getPrenom: string;
begin
  getPrenom := prenom;
end;
 
function TPersonne.getAge: integer;
begin
  getAge := age;
end;
 
destructor TPersonne.Done;
begin
  inherited Done;
end;
 
var
  personnes: array[1..10] of TPersonne;
  i, nombrePersonnes: integer;
  nom, prenom: string;
  age: integer;
 
begin
  write('Combien de personnes dans votre annuaire (Maximum : 10) : ');
  readln(nombrePersonnes);
  if nombrePersonnes > 10 then
    nombrePersonnes := 10;
  for i := 1 to nombrePersonnes do
  begin
    personnes[i].Init;
    write('Votre nom : ');
    readln(nom);
    personnes[i].setNom(nom);
    write('Votre prénom : ');
    readln(prenom);
    personnes[i].setPrenom(prenom);
    write('Votre age : ');
    readln(age);
    personnes[i].setAge(age);
  end;
 
  for i := 1 to nombrePersonnes do
    writeln('Nom : ', personnes[i].getNom, '  Prénom : ', personnes[i].getPrenom,
      '  Age : ', personnes[i].getAge);
  readln;
 
  for i := 1 to nombrePersonnes do
    personnes[i].Done;
 
end.

Créé le 21 juillet 2004 par Mathieu Dalbin

Exemple d'héritage

En reprenant l'objet TPersonne précédemment créé, déclarer le type dérivé TEtudiant, qui a en plus comme attributs privés cinq notes représentant cinq matières, et la moyenne de ses cinq notes. Les accesseurs en lecture et en écriture peuvent également être écris.

objets3.pas

Cacher/Afficher le codeSélectionnez

uses Objects;
 
type
  TPersonne = object(TObject)
  private
    nom, prenom: string;
    age: integer;
  public
    constructor Init;
    procedure setNom(_nom: string); virtual;
    procedure setPrenom(_prenom: string); virtual;
    procedure setAge(_age: integer); virtual;
    function getNom: string; virtual;
    function getPrenom: string; virtual;
    function getAge: integer; virtual;
    destructor Done; virtual;
  end;
 
type
  TEtudiant = object(TPersonne)
  private
    moyenne: real;
  public
    constructor Init;
    procedure setMoyenne(_moyenne: real); virtual;
    function getMoyenne: real; virtual;
    destructor Done; virtual;
  end;
 
constructor TPersonne.Init;
begin
  if not inherited Init then
    Fail;
end;
 
procedure TPersonne.setNom(_nom: string);
begin
  nom := _nom;
end;
 
procedure TPersonne.setPrenom(_prenom: string);
begin
  prenom := _prenom;
end;
 
procedure TPersonne.setAge(_age: integer);
begin
  age := _age;
end;
 
function TPersonne.getNom: string;
begin
  getNom := nom;
end;
 
function TPersonne.getPrenom: string;
begin
  getPrenom := prenom;
end;
 
function TPersonne.getAge: integer;
begin
  getAge := age;
end;
 
destructor TPersonne.Done;
begin
  inherited Done;
end;
 
constructor TEtudiant.Init;
begin
  if not inherited Init then
    Fail;
end;
 
procedure TEtudiant.setMoyenne(_moyenne: real);
begin
  moyenne := _moyenne;
end;
 
function TEtudiant.getMoyenne: real;
begin
  getMoyenne := moyenne;
end;
 
destructor TEtudiant.Done;
begin
  inherited Done;
end;
 
var
  etudiants: array[1..10] of TEtudiant;
  i, nombreEtudiants: integer;
  nom, prenom: string;
  age: integer;
  moyenne: real;
 
begin
  write('Combien d''étudiants dans votre annuaire (Maximum : 10) : ');
  readln(nombreEtudiants);
  if nombreEtudiants > 10 then
    nombreEtudiants := 10;
  for i := 1 to nombreEtudiants do
  begin
    etudiants[i].Init;
    write('Votre nom : ');
    readln(nom);
    etudiants[i].setNom(nom);
    write('Votre prénom : ');
    readln(prenom);
    etudiants[i].setPrenom(prenom);
    write('Votre age : ');
    readln(age);
    etudiants[i].setAge(age);
    write('Votre moyenne : ');
    readln(moyenne);
    etudiants[i].setMoyenne(moyenne);
  end;
 
  for i := 1 to nombreEtudiants do
    writeln('Nom : ', etudiants[i].getNom, '  Prénom : ', etudiants[i].getPrenom,
      '  Age : ', etudiants[i].getAge,
      '  Moyenne : ', etudiants[i].getMoyenne: 2: 2);
 
  for i := 1 to nombreEtudiants do
    etudiants[i].Done;
 
  readln;
end.

name="objets3.pas"/>

Créé le 21 juillet 2004 par Mathieu Dalbin

Pointeurs d'objets

En reprenant l'objet TPersonne, déclarer un type pointeur sur objet, nommé PPersonne. Ensuite initialiser plusieurs instances de l'objet TPersonne, et les remplir avec les données obtenues à partir du clavier (tel qu'à l'exercice "Pointeurs 2").

objets4.pas

Cacher/Afficher le codeSélectionnez

uses Objects;
 
type
  PPersonne = ^TPersonne;
  TPersonne = object(TObject)
  private
    nom, prenom: string;
    age: integer;
  public
    constructor Init;
    procedure setNom(_nom: string); virtual;
    procedure setPrenom(_prenom: string); virtual;
    procedure setAge(_age: integer); virtual;
    function getNom: string; virtual;
    function getPrenom: string; virtual;
    function getAge: integer; virtual;
    destructor Done; virtual;
  end;
 
constructor TPersonne.Init;
begin
  if not inherited Init then
    Fail;
end;
 
procedure TPersonne.setNom(_nom: string);
begin
  nom := _nom;
end;
 
procedure TPersonne.setPrenom(_prenom: string);
begin
  prenom := _prenom;
end;
 
procedure TPersonne.setAge(_age: integer);
begin
  age := _age;
end;
 
function TPersonne.getNom: string;
begin
  getNom := nom;
end;
 
function TPersonne.getPrenom: string;
begin
  getPrenom := prenom;
end;
 
function TPersonne.getAge: integer;
begin
  getAge := age;
end;
 
destructor TPersonne.Done;
begin
  inherited Done;
end;
 
var
  personnes: array[1..10] of PPersonne;
  i, nombrePersonnes: integer;
  nom, prenom: string;
  age: integer;
 
begin
  write('Combien de personnes dans votre annuaire (Maximum : 10) : ');
  readln(nombrePersonnes);
  if nombrePersonnes > 10 then
    nombrePersonnes := 10;
  for i := 1 to nombrePersonnes do
  begin
    new(personnes[i], Init);
    write('Votre nom : ');
    readln(nom);
    personnes[i]^.setNom(nom);
    write('Votre prénom : ');
    readln(prenom);
    personnes[i]^.setPrenom(prenom);
    write('Votre age : ');
    readln(age);
    personnes[i]^.setAge(age);
  end;
 
  for i := 1 to nombrePersonnes do
    writeln('Nom : ', personnes[i]^.getNom, '  Prénom : ',
      personnes[i]^.getPrenom, '  Age : ', personnes[i]^.getAge);
 
  for i := 1 to nombrePersonnes do
    dispose(personnes[i], Done);
 
  readln;
end.

Créé le 21 juillet 2004 par Mathieu Dalbin

Liste chaînées d'objets

Reprendre les objets TPersonne et PPersonne, et créer une liste chaînée de personnes. Remplir la liste avec les personnes dont les informations sont obtenues au clavier. On reprendra par exemple les procédures créées à l'exercice "Pointeurs 2".

objets5.pas

Cacher/Afficher le codeSélectionnez

uses Objects;
 
type
  PPersonne = ^TPersonne;
  TPersonne = object(TObject)
  private
    nom, prenom: string;
    age: integer;
  public
    constructor Init;
    procedure setNom(_nom: string); virtual;
    procedure setPrenom(_prenom: string); virtual;
    procedure setAge(_age: integer); virtual;
    function getNom: string; virtual;
    function getPrenom: string; virtual;
    function getAge: integer; virtual;
    destructor Done; virtual;
  end;
 
type
  PCellule = ^Cellule;
  Cellule = record
    personne: PPersonne;
    suivant: PCellule;
  end;
 
constructor TPersonne.Init;
begin
  if not inherited Init then
    Fail;
end;
 
procedure TPersonne.setNom(_nom: string);
begin
  nom := _nom;
end;
 
procedure TPersonne.setPrenom(_prenom: string);
begin
  prenom := _prenom;
end;
 
procedure TPersonne.setAge(_age: integer);
begin
  age := _age;
end;
 
function TPersonne.getNom: string;
begin
  getNom := nom;
end;
 
function TPersonne.getPrenom: string;
begin
  getPrenom := prenom;
end;
 
function TPersonne.getAge: integer;
begin
  getAge := age;
end;
 
destructor TPersonne.Done;
begin
  inherited Done;
end;
 
procedure ajouter(var liste: PCellule; nom, prenom: string; age: integer);
var
  p: PCellule;
begin
  new(p);
  new(p^.personne, Init);
  p^.personne^.setNom(nom);
  p^.personne^.setPrenom(prenom);
  p^.personne^.setAge(age);
  p^.suivant := liste;
  liste := p;
end;
 
procedure afficher(liste: PCellule);
var
  p: PCellule;
begin
  p := liste;
  while p <> nil do
  begin
    writeln('Nom : ', p^.personne^.getNom, '  Prénom : ', p^.personne^.getPrenom,
      '  Age : ', p^.personne^.getAge);
    p := p^.suivant;
  end;
end;
 
procedure vider(liste: PCellule);
var
  p, r: PCellule;
begin
  p := liste;
  while (p <> nil) do
  begin
    r := p^.suivant;
    dispose(p^.personne, Done);
    dispose(p);
    p := r;
  end;
end;
 
var
  i, nombrePersonnes: integer;
  nom, prenom: string;
  age: integer;
  liste: PCellule;
 
begin
  write('Combien de personnes dans votre annuaire (Maximum : 10) : ');
  readln(nombrePersonnes);
  while (nombrePersonnes > 0) do
  begin
    write('Votre nom : ');
    readln(nom);
    write('Votre prénom : ');
    readln(prenom);
    write('Votre age : ');
    readln(age);
    ajouter(liste, nom, prenom, age);
    dec(nombrePersonnes);
  end;
 
  afficher(liste);
 
  vider(liste);
 
  readln;
end.

Créé le 21 juillet 2004 par Mathieu Dalbin

Polymorphisme

A partir de l'objet TPersonne, définir un autre type TSalarie, à la manière de TEtudiant. Ce type TSalarie pourra contenir par exemple en attributs privés son salaire et le nom de son employeur. Définir également des types pointeurs sur objets pour les types TEtudiant et TSalarie. A ce stade, trois types pointeurs sur objet doivent être définis : PPersonne, PEtudiant et PSalarie. Pour les trois types de départ, ajouter une fonction Presentation, qui retourne une chaîne de caractères donnant le nom et le prénom pour TPersonne, les nom et prénom et la moyenne pour TEtudiant, les nom, prénoms, et salaire pour TSalarie. Reprendre la liste chaînée précédente et y inclure des objets des trois types définis. Après avoir rempli la liste, on affichera à l'écran le résultat de la fonction de Presentation pour tous les éléments de la liste. Enfin on videra la liste correctement avec la procédure conçue à cet effet.

.pas

Cacher/Afficher le codeSélectionnez

uses Objects;
 
type
  PPersonne = ^TPersonne;
  TPersonne = object(TObject)
  private
    nom, prenom: string;
    age: integer;
  public
    constructor Init;
    procedure setNom(_nom: string); virtual;
    procedure setPrenom(_prenom: string); virtual;
    procedure setAge(_age: integer); virtual;
    function getNom: string; virtual;
    function getPrenom: string; virtual;
    function getAge: integer; virtual;
    function Presentation: string; virtual;
    destructor Done; virtual;
  end;
 
type
  PEtudiant = ^TEtudiant;
  TEtudiant = object(TPersonne)
  private
    moyenne: real;
  public
    constructor Init;
    procedure setMoyenne(_moyenne: real); virtual;
    function getMoyenne: real; virtual;
    function Presentation: string; virtual;
    destructor Done; virtual;
  end;
 
type
  PSalarie = ^TSalarie;
  TSalarie = object(TPersonne)
  private
    salaire: integer;
  public
    constructor Init;
    procedure setSalaire(_salaire: integer); virtual;
    function getSalaire: integer; virtual;
    function Presentation: string; virtual;
    destructor Done; virtual;
  end;
 
type
  PCellule = ^Cellule;
  Cellule = record
    personne: PPersonne;
    suivant: PCellule;
  end;
 
constructor TPersonne.Init;
begin
  if not inherited Init then
    Fail;
end;
 
procedure TPersonne.setNom(_nom: string);
begin
  nom := _nom;
end;
 
procedure TPersonne.setPrenom(_prenom: string);
begin
  prenom := _prenom;
end;
 
procedure TPersonne.setAge(_age: integer);
begin
  age := _age;
end;
 
function TPersonne.getNom: string;
begin
  getNom := nom;
end;
 
function TPersonne.getPrenom: string;
begin
  getPrenom := prenom;
end;
 
function TPersonne.getAge: integer;
begin
  getAge := age;
end;
 
function TPersonne.Presentation: string;
var
  sage: string;
begin
  str(age, sage);
  Presentation := 'Nom : ' + nom + '  Prénom : ' + prenom + '  Age : ' + sage;
end;
 
destructor TPersonne.Done;
begin
  inherited Done;
end;
 
constructor TEtudiant.Init;
begin
  if not inherited Init then
    Fail;
end;
 
procedure TEtudiant.setMoyenne(_moyenne: real);
begin
  moyenne := _moyenne;
end;
 
function TEtudiant.getMoyenne: real;
begin
  getMoyenne := moyenne;
end;
 
function TEtudiant.Presentation: string;
var
  smoyenne: string;
begin
  str(moyenne: 2: 2, smoyenne);
  Presentation := (inherited Presentation) + '  Moyenne : ' + smoyenne;
end;
 
destructor TEtudiant.Done;
begin
  inherited Done;
end;
 
constructor TSalarie.Init;
begin
  if not inherited Init then
    Fail;
end;
 
procedure TSalarie.setSalaire(_salaire: integer);
begin
  salaire := _salaire;
end;
 
function TSalarie.getSalaire: integer;
begin
  getSalaire := salaire;
end;
 
function TSalarie.Presentation: string;
var
  ssalaire: string;
begin
  str(salaire, ssalaire);
  Presentation := (inherited Presentation) + '  Salaire : ' + ssalaire;
end;
 
destructor TSalarie.Done;
begin
  inherited Done;
end;
 
procedure ajouter(var liste: PCellule; personne: PPersonne);
var
  p: PCellule;
begin
  new(p);
  p^.personne := personne;
  p^.suivant := liste;
  liste := p;
end;
 
procedure afficher(liste: PCellule);
var
  p: PCellule;
begin
  p := liste;
  while p <> nil do
  begin
    writeln(p^.personne^.Presentation);
    p := p^.suivant;
  end;
end;
 
procedure vider(liste: PCellule);
var
  p, r: PCellule;
begin
  p := liste;
  while (p <> nil) do
  begin
    r := p^.suivant;
    dispose(p^.personne, Done);
    dispose(p);
    p := r;
  end;
end;
 
var
  nombrePersonnes, typePersonne: integer;
  nom, prenom: string;
  age: integer;
  moyenne: real;
  salaire: integer;
  p: PPersonne;
  liste: PCellule;
 
begin
  write('Combien de personnes dans votre annuaire (Maximum : 10) : ');
  readln(nombrePersonnes);
  while (nombrePersonnes > 0) do
  begin
    write('Quel type (1 pour Etudiant, 2 pour Salarié, autre pour Personne) : ');
    readln(typePersonne);
    write('Votre nom : ');
    readln(nom);
    write('Votre prénom : ');
    readln(prenom);
    write('Votre age : ');
    readln(age);
    case typePersonne of
      1:
        begin
          write('Votre moyenne : ');
          readln(moyenne);
          p := new(PEtudiant, Init);
          p^.setNom(nom);
          p^.setPrenom(prenom);
          p^.setAge(age);
          PEtudiant(p)^.setMoyenne(moyenne);
          ajouter(liste, p);
        end;
      2:
        begin
          write('Votre salaire : ');
          readln(salaire);
          p := new(PSalarie, Init);
          p^.setNom(nom);
          p^.setPrenom(prenom);
          p^.setAge(age);
          PSalarie(p)^.setSalaire(salaire);
          ajouter(liste, p);
        end;
    else
      begin
        p := new(PPersonne, Init);
        p^.setNom(nom);
        p^.setPrenom(prenom);
        p^.setAge(age);
        ajouter(liste, p);
      end;
    end;
    dec(nombrePersonnes);
  end;
 
  afficher(liste);
 
  vider(liste);
 
  readln;
end.

Créé le 21 juillet 2004 par Mathieu Dalbin

Version hors-ligne