// Purpose.  Flyweight                  #include <iostream.h>
//
// Discussion.  Trying to use objects   const int X = 6;
// at very low levels of granularity    const int Y = 10;
// is nice, but the overhead may be
// prohibitive.  Flyweight suggests     class Gazillion {
// removing the non-shareable state     public:
// from the class, and having the cli-     Gazillion( int in ) {
// ent supply it when methods are             val1_ = in;
// called.  This places more respon-          cout << "ctor: "<< val1_<<endl; }
// sibility on the client, but, con-       ~Gazillion() {
// siderably fewer instances of the           cout << val1_ << ' '; }
// Flyweight class are now created.        void report( int in ) {
// Sharing of these instances is fa-          cout << val1_ << in << ' '; }
// cilitated by introducing a Factory   private:
// class that maintains a "cache" of       int  val1_;
// existing Flyweights.                 };
//
// In this example, the "X" state is    class Factory {
// considered shareable (within each    public:
// row anyways), and the "Y" state has     static Gazillion* getFly(int in) {
// been externalized (it is supplied          if ( ! pool_[in])
// by the client when report() is                pool_[in] =
// called).                                              new Gazillion( in );
                                              return pool_[in];
#include <iostream.h>                      }
                                           static void cleanUp() {
const int X = 6;                              cout << "dtors: ";
const int Y = 10;                             for (int i=0; i < X; i++)
                                                 if (pool_[i])
class Gazillion {                                   delete pool_[i];
public:                                       cout << endl;
   Gazillion() {                           }
      val1_ = num_ / Y;                 private:
      val2_ = num_ % Y;                    static Gazillion*  pool_[X];
      num_++;                           };
   }
   void report() {                      Gazillion*  Factory::pool_[]  = {
      cout << val1_ << val2_ << ' ';                             0,0,0,0,0,0 };
   }
private:                                void main( void )
   int    val1_;                        {
   int    val2_;                           for (int i=0; i < X; i++)
   static int num_;                        {
};                                            for (int j=0; j < Y; j++)
                                                 Factory::getFly(i)->report(j);
int Gazillion::num_ = 0;                      cout << endl;
                                           }
void main( void )                          Factory::cleanUp();
{                                       }
   Gazillion  matrix[X][Y];
   for (int i=0; i < X; i++)            // ctor: 0
   {                                    // 00 01 02 03 04 05 06 07 08 09
      for (int j=0; j < Y; j++)         // ctor: 1
         matrix[i][j].report();         // 10 11 12 13 14 15 16 17 18 19
      cout << endl;                     // ctor: 2
   }                                    // 20 21 22 23 24 25 26 27 28 29
}                                       // ctor: 3
                                        // 30 31 32 33 34 35 36 37 38 39
// 00 01 02 03 04 05 06 07 08 09        // ctor: 4
// 10 11 12 13 14 15 16 17 18 19        // 40 41 42 43 44 45 46 47 48 49
// 20 21 22 23 24 25 26 27 28 29        // ctor: 5
// 30 31 32 33 34 35 36 37 38 39        // 50 51 52 53 54 55 56 57 58 59
// 40 41 42 43 44 45 46 47 48 49        // dtors: 0 1 2 3 4 5
// 50 51 52 53 54 55 56 57 58 59