Voir la source de Composition (programmation)

{{homon|Composition}}
{{Ébauche|informatique}}
En [[programmation informatique]], la '''composition''' est une technique qui permet de combiner plusieurs éléments de programmation entre eux pour obtenir un élément ayant une fonctionnalité plus complexe.  On distingue la composition de fonctions, la composition d'objets, et la composition dans les modèles.

== Composition de fonctions ==
La composition de fonctions consiste à définir une nouvelle fonction en combinant plusieurs fonctions entre elles<ref>{{Article |langue=EN |auteur1= |prénom1=Donald B. |nom1=McIntyre |titre=The role of composition in computer programming |périodique=ACM SIGAPL APL Quote Quad |volume=25 |numéro=4 |date=1995-06-08 |issn=0163-6006 |doi=10.1145/206944.206985 |lire en ligne=https://doi.org/10.1145/206944.206985 |consulté le=2020-10-11 |pages=116–133 }}</ref>.  

Ce procédé s'inspire directement de la [[Composition de fonctions|composition de fonctions en mathématiques]], où le résultat d'une fonction est utilisé comme paramètre d'une autre.  Deux [[Fonction (mathématiques)|fonctions]] <math>f</math> et <math>g</math> telles que <math>z=f(y)</math> et <math>y=g(x)</math> peuvent par exemple être combinées en une fonction <math>h</math> telle que <math>z=f(g(x))</math>.  En [[programmation procédurale]], cette composition peut s'exprimer en une suite d'instructions:  <syntaxhighlight lang="cpp">
double h(double x)
{
    double y = g(x);
    double z = f(y);
    return z;
}
</syntaxhighlight>Elle peut aussi combiner les expressions en une forme plus compacte<ref>{{Ouvrage|langue=en|nom1=Cox, Brad|titre=Object-oriented programming|sous-titre=an evolutionary approach|éditeur=Addison-Wesley Pub. Co|année=1991|pages totales=15-17|isbn=0-201-54834-8|isbn2=978-0-201-54834-1|oclc=22767291|lire en ligne=https://www.worldcat.org/oclc/22767291|consulté le=2020-10-11}}</ref>, ce qui en facilite la maintenance<ref>{{Ouvrage|langue=en|nom1=DeMarco, Tom.|titre=Why does software cost so much? : and other puzzles of the Information Age|éditeur=Dorset House Pub|année=1995|pages totales=133-135|isbn=0-932633-34-X|isbn2=978-0-932633-34-7|oclc=32922371|lire en ligne=https://www.worldcat.org/oclc/32922371|consulté le=2020-10-11}}</ref>:  <syntaxhighlight lang="cpp">
double h(double x)
{
    return f(g(x));
}
</syntaxhighlight>Certains langages de [[programmation fonctionnelle]] comme [[F sharp|F#]] offrent des opérateurs pour composer des fonctions de cette manière<ref>{{Lien web |langue=en |auteur= |nom=Microsoft |titre=Functions F# - Function composition and pipelining |url=https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/functions/ |site=docs.microsoft.com |date= |consulté le=2020-10-11}}</ref>: <syntaxhighlight lang="f#">
let h = g >> f
</syntaxhighlight>Dans le domaine de la programmation, la composition de fonction désigne par extension toute forme de combinaison de fonctions ou de procédures.

== Composition d'objets ==
La [[programmation orientée objet]] se base sur le concept d'objets et le principe de l'[[Encapsulation (programmation)|encapsulation]] pour structurer les données et les opérations associées.  La composition d'objet consiste alors à définir des objets ou des types composés en combinant des objets ou des types plus simples tout en respectant leur interface et en ignorant tout de leur fonctionnement interne<ref>{{Ouvrage|langue=en|nom1=Gamma, Erich.|nom2=Helm, Richard|nom3=Johnson, Ralph E.,|nom4=Vlissides, John.|titre=Design patterns : elements of reusable object-oriented software|éditeur=[[Addison-Wesley]]|année=1995|isbn=0-201-63361-2|isbn2=978-0-201-63361-0|oclc=31171684|lire en ligne=https://www.worldcat.org/oclc/31171684|consulté le=2020-10-11}}</ref>.  

La composition se distingue du mécanisme de l'[[Héritage multiple|héritage]] dans les langages à base de classes :  l'héritage consiste à spécialiser des classes en leur ajoutant des éléments supplémentaires et en redéfinissant certains comportements. La classe d'un objet est déterminée au moment de sa création (on dit que l'objet est une instance de la classe) et l'objet ne peut pas changer de classe après sa création. La composition d'objets reste par contre dynamique : chaque composant est susceptible d'être remplacé à tout moment par un composant d'une classe compatible.

La composition se distingue également du mécanisme de prototypage utilisée par des [[Programmation orientée prototype|langages orientés prototypes]] comme [[JavaScript]] : un nouvel objet créé à partir d'un prototype en hérite les compositions du prototype mais peut lui-même faire l'objet de compositions supplémentaires.

== Modélisation conceptuelle ==
[[Image:UML Rel composition.jpg|vignette|75px|symbole graphique de la Composition dans les diagrammes de la modélisation [[Unified Modeling Language|UML]].]]
La composition d'objets peut mettre en œuvre au niveau de la programmation des propriétés et des relations d'association, d'agrégation ou de composition d'un modèle de classes en UML. Au niveau conceptuel la composition a toutefois un sens plus restrictif<ref>{{Lien web |langue=en |auteur=OMG |titre=Unified Modeling Language Specification Version 2.5.1 |url=https://www.omg.org/spec/UML/About-UML/ |site=www.omg.org |date=2017 |consulté le=2020-10-11 |page=109-110,197-201}}</ref>.  

Un lien de '''composition''' symbolise l'existence d'une [[Agrégation (programmation)|agrégation]] particulière, dite 'forte', entre deux entités (classes).

Une composition est définie par les points suivants :

: Durée de vie : toute classe agrégée est détruite quand la classe composite est détruite.
: Exclusivité : une classe agrégée ne peut l'être que par une seule classe composite.
: Notion de « fait partie de ».

La classe Voiture est une classe composite composée d'un élément de la classe Carburateur (un carburateur). La classe Carburateur est une classe agrégée. Quand une instance de la classe Voiture (une voiture) est détruite (dans un accident par exemple), le carburateur (instance de la classe Carburateur) aussi. Le carburateur fait partie de la voiture.

À noter que la distinction entre composition et agrégation n'est pas absolue : c'est le contexte qui détermine ce choix. Ainsi une voiture peut être vue comme l'agrégation d'un habitacle et 4 roues du point de vue d'un logiciel de casse automobile (la destruction de la voiture n'entrainera pas celle des roues si elles sont récupérées auparavant), ou bien comme une composition du point de vue d'un logiciel de simulation de comportement routier (où les roues nécessitent d'être traitées comme des entités distinctes, mais où le véhicule reste considéré comme un tout).

En [[UML (informatique)|UML]], la composition se représente par un trait plein orné d'un [[losange]] noir du côté de la classe composite.

== Exemple de code en C++ ==
<syntaxhighlight lang="cpp">
// Composition
class Voiture
{
  private :
    // Tout objet de type Voiture est responsable de l'attribut 'carbu', lequel est un objet de type Carburateur. 
    // Quand un objet de type Voiture est créé, son attribut 'carbu' est créé automatiquement. 
    // Quand un objet de type Voiture est détruit, son attribut 'carbu' est également détruit.
    Carburateur carbu;
  public :
    const Carburateur & getCarbu() const { // Méthode accesseur pour accéder en lecture seule à l'attribut 'carbu'
      return carbu;
    }
    void setCarbu(const Carburateur & unCarbu) { // Méthode mutateur pour initialiser l'attribut 'carbu'
      carbu = unCarbu;
    }
};
</syntaxhighlight>

== Notes et références ==
{{Traduit de/Référence|lang1=EN|art1=Function composition (computer science)|art2=Object composition|id1=956135008|lang2=EN|id2=982945958}}
{{Références|groupe=}}
{{Palette Unified Modeling Language}}
{{Portail|informatique}}

[[Catégorie:Programmation orientée objet]]

[[ja:構造体]]