Modèle de conception C brève introduction au modèle de poids mouche

Flyweight : utilisez la technologie de partage pour prendre en charge efficacement un grand nombre d'objets à granularité fine.

Quatre classes de rôles :

Classe de poids mouche Flyweight : la super classe ou interface de toutes les classes de poids mouche spécifiques. Grâce à cette interface, Flyweight peut accepter et agir sur des états externes.

Flyweight Flyweight Factory Class : Une usine de poids mouche utilisée pour créer et gérer Flyweight Lorsque l'utilisateur demande un Flyweight, l'objet FlyweightFactory fournit une instance créée ou en crée une (si elle n'existe pas).

Classe de poids mouche en béton ConcreteFlyweight : héritez de la super classe Flyweight ou implémentez l'interface Flyweight et ajoutez de l'espace de stockage pour l'état interne.

UnSharedConcreteFlyweight fait référence à des sous-classes Flyweight spécifiques qui n'ont pas besoin d'être partagées, faisant référence aux sous-classes Flyweight qui n'ont pas besoin d'être partagées. Parce que le partage de classes d'interface Flyweight est possible, mais le partage n'est pas obligatoire.

Implémentation du modèle :

[code]//享元类
class Flyweight{
public:
    virtual void Operation(int extrinsicState){}
};

//具体享元类
class ConcreteFlyweight: public Flyweight{
public:
    virtual void Operation(int extrinsicState)override{
        std::cout << "ConcreteFlyweight: " << extrinsicState << std::endl;
    }
};

//不需共享的Flyweight子类
class UnSharedConcreteFlyweight: public Flyweight{
public:
    virtual void Operation(int extrinsicState){
        std::cout << "UnSharedConcreteFlyweight: " << extrinsicState << std::endl;
    }
};

//享元工厂，用来创建并管理Flyweight对象
class FlyweightFactory{
private:
    std::map<std::string, Flyweight*> flyweights;
public:
    FlyweightFactory(){
        flyweights["X"] = new ConcreteFlyweight;
        flyweights["Y"] = new ConcreteFlyweight;
        flyweights["Z"] = new ConcreteFlyweight;
    }
    Flyweight* GetFlyweight(std::string key){
        return (Flyweight*)flyweights[key];
    }
};

Client :

[code]//Client
int main(){
    //外部状态
    int extrinsicState = 22;
    //工厂
    FlyweightFactory *f = new FlyweightFactory;
    Flyweight* fx = f->GetFlyweight("X");
    fx->Operation(--extrinsicState);  //Output: ConcreteFlyweight: 21

    Flyweight* fy = f->GetFlyweight("Y");
    fy->Operation(--extrinsicState);  //Output: ConcreteFlyweight: 20

    Flyweight* fz = f->GetFlyweight("Z");
    fz->Operation(--extrinsicState);  //Output: ConcreteFlyweight: 19

    Flyweight *uf = new UnSharedConcreteFlyweight;  //Output: UnSharedConcreteFlyweight: 18
    uf->Operation(--extrinsicState);

    return 0;
}

Avantages du modèle Flyweight :

Si une application utilise un grand nombre d'objets, ce qui doit être pris en compte lorsqu'un grand nombre de ces objets crée une surcharge de stockage importante.

La plupart des états d'un objet peuvent utiliser l'état externe. Si l'état externe d'un objet est supprimé, de nombreux groupes d'objets peuvent être remplacés par relativement peu d'objets partagés. Dans ce cas, le modèle de poids mouche peut être pris en compte.

Ce qui précède est le contenu de la brève introduction du modèle de conception C au modèle flyweight. Pour plus de contenu connexe, veuillez prêter attention au site Web PHP chinois (www.php.cn) !