C++, Qt, OpenGL, CUDA

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Les design patterns en C++14 ======

But : proposer une implémentation en C++ "moderne" (ou expliquer pourquoi un design pattern n'est plus pertinent en C++ "moderne"). ie mettre a jour l'article de Davide Come : http://come-david.developpez.com/tutoriels/dps/

Dans un premier temps, principalement les design patterns du GoF.

Sources :
  * http://en.wikipedia.org/wiki/Software_design_pattern
  * https://sourcemaking.com/design_patterns
  * http://www.dofactory.com/net/design-patterns
  * http://www.oodesign.com/
  * http://en.wikibooks.org/wiki/C%2B%2B_Programming/Code/Design_Patterns
  * http://www.bogotobogo.com/DesignPatterns/introduction.php
  * http://openclassrooms.com/courses/programmez-en-oriente-objet-en-php/les-design-patterns
  * http://openclassrooms.com/courses/programmation-objet-avancee-la-conception-avant-tout-design-patterns-a-l-emploi
  * https://www.ics.com/designpatterns/book/index.html
  * ... il y a tellement de sources qui parlent de cela...

===== Creational patterns =====

==== Abstract factory ====
 
Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

==== Builder ====

Separate the construction of a complex object from its representation, allowing the same construction process to create various representations.

==== Factory method ====

Define an interface for creating a single object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses (dependency injection[15]).

==== Lazy initialization ====

Tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the first time it is needed. This pattern appears in the GoF catalog as "virtual proxy", an implementation strategy for the Proxy pattern.

==== Multiton ====

Ensure a class has only named instances, and provide global point of access to them.

==== Object pool ====

Avoid expensive acquisition and release of resources by recycling objects that are no longer in use. Can be considered a generalisation of connection pool and thread pool patterns.

==== Prototype ====

Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.

==== Resource acquisition is initialization ====

Ensure that resources are properly released by tying them to the lifespan of suitable objects.

==== Singleton ====

Ensure a class has only one instance, and provide a global point of access to it.

===== Structural patterns =====

==== Adapter ====

Or Wrapper or Translator.

Convert the interface of a class into another interface clients expect. An adapter lets classes work together that could not otherwise because of incompatible interfaces. The enterprise integration pattern equivalent is the translator.

==== Bridge ====

Decouple an abstraction from its implementation allowing the two to vary independently.

==== Composite ====

Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.

==== Decorator ====

Attach additional responsibilities to an object dynamically keeping the same interface. Decorators provide a flexible alternative to subclassing for extending functionality.

==== Facade ==== 

Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.

==== Flyweight ====

Use sharing to support large numbers of similar objects efficiently.

==== Front Controller ====

The pattern relates to the design of Web applications. It provides a centralized entry point for handling requests.

==== Module ====

Group several related elements, such as classes, singletons, methods, globally used, into a single conceptual entity.

==== Proxy ====

Provide a surrogate or placeholder for another object to control access to it.

==== Twin ====

Twin allows modeling of multiple inheritance in programming languages that do not support this feature.

===== Behavioral patterns =====

==== Blackboard ====

Generalized observer, which allows multiple readers and writers. Communicates information system-wide.

==== Chain of responsibility ====

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.

==== Command ====

Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.

==== Interpreter ====

Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.

==== Iterator ====

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

==== Mediator ====

Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.

==== Memento ====

Without violating encapsulation, capture and externalize an object's internal state allowing the object to be restored to this state later.

==== Null object ====

Avoid null references by providing a default object.

==== Observer ====

Or Publish/subscribe

Define a one-to-many dependency between objects where a state change in one object results in all its dependents being notified and updated automatically.

==== Servant ====

Define common functionality for a group of classes

==== Specification ====

Recombinable business logic in a Boolean fashion

==== State ====

Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.

==== Strategy ==== 

Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

==== Template method ====

Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.

==== Visitor ====

Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates.

===== Concurrency patterns =====

(plus tard)
C++, Qt, OpenGL, CUDA

Outils d'utilisateurs

Outils du Site

Outils de la Page
