Ada : Notions avancées et Programmation Orientée Objet

Nous avons abordé dans la partie précédente des notions essentielles de programmation, mais nous n'avons pas encore découvert la Programmation Orientée Objet. Cette partie n'a pas pour but de révolutionner votre façon de coder mais plutôt d'y apporter des améliorations. Créer des packages plus génériques, gérer des erreurs qui pourraient survenir, gérer de manière plus dynamique vos allocations/désallocation de mémoire…

Comme précédemment, elle comportera un fil conducteur autour duquel viendront se greffer des chapitres un peu plus hors sujet (ou plutôt hors thème). Mon fil conducteur ne sera plus les tableaux ou les pointeurs, mais les packages et la Programmation Orientée Objet.

Eh ! Y'a erreur ! On a déjà vu les packages dans la partie III, non ?! :euh:

Je le sais bien, mais il nous reste beaucoup à dire sur les packages. Nous allons aborder ce que l'on appelle les classes et les méthodes. Que les néophytes se rassurent, tout ira bien et nous prendrons plus de temps qu'il n'en faut pour comprendre ce que cela signifie. Et que les aficionados de la programmation orientée objet calment leurs ardeurs : Ada gère les notions de classes d'une manière particulière, très différente des C++, Java et autres Python.

  1. Algorithmique : tri et complexité

    1. Algorithmes de tri lents

    2. Algorithmes de tri plus rapides

    3. Théorie : complexité d'un algorithme

    4. Mesures de complexité des algorithmes

  2. Variables III : Gestion bas niveau des données

    1. Représentation des nombres entiers

    2. Représentation du texte

    3. Représentation des nombres décimaux en virgule flottante

  3. La programmation modulaire II : Encapsulation

    1. Qu'est-ce qu'un objet ?

    2. Un package… privé

    3. Un package privé et limité

    4. Exercices

  4. La programmation modulaire III : Généricité

    1. Généricité : les grandes lignes

    2. Créer et utiliser une méthode générique

    3. Paramètres génériques de types simples et privés

    4. Paramètres génériques de types composites et programmes

    5. Packages génériques

  5. La programmation modulaire IV : Héritage et dérivation

    1. Pour bien commencer

    2. Héritage

    3. Dérivation et types étiquetés

  6. La programmation modulaire V : Polymorphisme, abstraction et héritage multiple

    1. Polymorphisme

    2. Abstraction

    3. Héritage multiple

  7. La programmation modulaire VI : Finalisation et types contrôlés

    1. Objectifs et prérequis

    2. Mise en œuvre

  8. [TP] Bataille navale

    1. Règles du jeu

    2. Cahier des charges

    3. Une solution possible

  9. Les exceptions

    1. Fonctionnement d'une exception

    2. Traitement d'une exception

    3. Exceptions prédéfinies

    4. Créer et lever ses propres exceptions

    5. Assertions et contrats

  10. Multitasking

    1. Parallélisme, tâches et types tâches

    2. Communication inter-tâche directe

    3. Communication inter-tâche indirecte

    4. Compléments : priorités et POO

    5. Exercices fondamentaux

  11. Interfaçage entre Ada et le C

    1. Quelques préparatifs

    2. Hello World : du C à l'Ada

    3. Quelques menus problèmes

Ça y est ! Vous êtes venus à bout de cette quatrième et infâme partie ! Que de théorie. J'aperçois d'ici la fumée qui se dégage des neurones en surchauffe ! :p Vous pouvez désormais passer à la dernière partie (si ce n'est pas déjà fait :-° ) sur la programmation événementielle avec GTK. À vous les fenêtres et les boutons, enfin ! Cette cinquième partie sera à l'exact opposé de la quatrième : très pratique, avec des objectifs bien plus palpitants que de connaître le temps d'exécution d'un algorithme de tri, et surtout, c'est le couronnement de tous les efforts fournis pour parvenir jusque-là. Alors régalez-vous !