[Ouvert de nouveau a cause de l'échange de forum]
[Corrigé les fautes de l'exemple Dispatcher]
Aurora
Bien que ce projet et SFML ne sont pas directement liés, je pense que quelques gens peuvent le trouver intéressant. Originalement une partie de Thor, Aurora est maintenant une bibliothèque autonome qui offre des fonctionnalités diverses pour C++.
Une exemple d'un smart pointer:
#include <Aurora/SmartPtr/CopiedPtr.hpp>
namespace sf { class Drawable; } // Forward declaration is enough
struct GameObject
{
aur::CopiedPtr<sf::Drawable> drawable;
};
#include <SFML/Graphics.hpp>
int main()
{
GameObject a, b, c;
a.drawable.reset(new sf::RectangleShape);
b.drawable.reset(new sf::Sprite); // different derivates
c = a; // performs a deep copy
} // deletes everything correctly
sf::Drawable est une classe de base abstraite, mais on peut la mettre dans un smart-pointer. En conséquence, c'est possible de faire des copies comme d'habitude -- l'objet derivé (sf::RectangleShape) est copié correctment. Tout ça se passe sans un constructeur par recopie, un opérateur d'affectation, ou une fonction clone() virtuelle.
Un autre exemple: Les dispatchers qui sont capable de choisir la fonction correcte d'une nombre de candidates, tandis que les argument soyent seulement connu pendant l'éxecution du programme. Comme ça, on peut utiliser des classes de base (comme Object dans l'exemple), mais l'interaction entre deux objets peut être réalisée avec toute l'information des types. Il ne faut pas différentier des cas.
#include <Aurora/Dispatch.hpp>
#include <iostream>
// Example class hierarchy
class Object { public: virtual ~Object() {} };
class Asteroid : public Object {};
class Ship : public Object {};
// Functions for collision with different argument types
void collision(Asteroid*, Asteroid*) { std::cout << "Asteroid-Asteroid\n"; }
void collision(Asteroid*, Ship*) { std::cout << "Asteroid-Ship\n"; }
void collision(Ship*, Ship*) { std::cout << "Ship-Ship\n"; }
int main()
{
// Create dispatcher and register functions
aur::DoubleDispatcher<Object*> dispatcher;
dispatcher.add<Asteroid, Asteroid>(&collision);
dispatcher.add<Asteroid, Ship> (&collision);
dispatcher.add<Ship, Ship> (&collision);
// Base class pointers (no static type information about derived classes)
Object* a = new Asteroid;
Object* s = new Ship;
// Invoke functions, let dispatcher choose the correct overload
dispatcher.call(a, s); // Output: "Asteroid-Ship"
dispatcher.call(a, a); // Output: "Asteroid-Asteroid"
dispatcher.call(s, s); // Output: "Ship-Ship"
delete a;
delete s;
}
Aurora utilise la license zlib/libpng. Parce qu'il s'agit d'une bibliothèque header-only, vous n'avez pas besoin de compiler ou lier quelque chose.
Links
Page web du projet Aurora (http://www.bromeon.ch/libraries/aurora/index.html)
GitHub (https://github.com/Bromeon/Aurora)
P.S. Excusez les expressions spécifiques de C++, je n'en connais pas toutes en français ;)