笔记：Gof设计模式--Composite

1、意图

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

 

2、适应性

  Use the Composite pattern when

  •  you want to represent part-whole hierarchies of objects.  

  •  you want clients to be able to ignore the difference between compositions of objects and individual objects. Clients will treat all objects in the composite structure uniformly. 

 

3、结构

 

 

4、示例代码

 Equipment class defines an interface for all equipment in the part-whole hierarchy.

 class Equipment { 
    public: 
        virtual ~Equipment(); 
     
        const char* Name() { return _name; } 
     
        virtual Watt Power(); 
        virtual Currency NetPrice(); 
        virtual Currency DiscountPrice(); 
     
        virtual void Add(Equipment*); 
        virtual void Remove(Equipment*); 
        virtual Iterator* CreateIterator(); 
    protected: 
        Equipment(const char*); 
    private: 
        const char* _name; 
    }; 

 

 Subclasses of Equipment might include Leaf classes that represent disk drives, integrated circuits, and switches:

class FloppyDisk : public Equipment { 
    public: 
        FloppyDisk(const char*); 
        virtual ~FloppyDisk(); 
     
        virtual Watt Power(); 
        virtual Currency NetPrice(); 
        virtual Currency DiscountPrice(); 
    }; 

 

 

 CompositeEquipment is the base class for equipment that contains other equipment. It's also a subclass of Equipment.

 class CompositeEquipment : public Equipment { 
    public: 
        virtual ~CompositeEquipment(); 
     
        virtual Watt Power(); 
        virtual Currency NetPrice(); 
        virtual Currency DiscountPrice(); 
     
        virtual void Add(Equipment*); 
        virtual void Remove(Equipment*); 
        virtual Iterator* CreateIterator(); 
     
    protected: 
        CompositeEquipment(const char*); 
    private: 
        List _equipment; 
    }; 

 CompositeEquipment is the base class for equipment that contains other equipment. It's also a subclass of Equipment.

 

 A default implementation of NetPrice might use CreateIterator to sum the net prices of the subequipment2:

 Currency CompositeEquipment::NetPrice () { 
        Iterator* i = CreateIterator(); 
        Currency total = 0; 
     
        for (i->First(); !i->IsDone(); i->Next()) { 
            total += i->CurrentItem()->NetPrice(); 
        } 
        delete i; 
        return total; 
    } 

  Now we can represent a computer chassis as a subclass of CompositeEquipment calledChassis. Chassis inherits the child-related operations from CompositeEquipment.

class Chassis : public CompositeEquipment { 
    public: 
        Chassis(const char*); 
        virtual ~Chassis(); 
     
        virtual Watt Power(); 
        virtual Currency NetPrice(); 
        virtual Currency DiscountPrice(); 
    }; 

 We can define other equipment containers such as Cabinet and Bus in a similar way. That gives us everything we need to assemble equipment into a (pretty simple) personal computer:

    Cabinet* cabinet = new Cabinet("PC Cabinet"); 
    Chassis* chassis = new Chassis("PC Chassis");      
    cabinet->Add(chassis);      
    Bus* bus = new Bus("MCA Bus"); 
    bus->Add(new Card("16Mbs Token Ring"));      
    chassis->Add(bus); 
    chassis->Add(new FloppyDisk("3.5in Floppy"));      
    cout << "The net price is " << chassis->NetPrice() << endl;