home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #18 / NN_1992_18.iso / spool / comp / lang / cplus / 12581 < prev    next >
Encoding:
Text File  |  1992-08-19  |  3.7 KB  |  115 lines
  1. Path: sparky!uunet!pipex!demon!cix.compulink.co.uk!vadim
  2. Newsgroups: comp.lang.c++
  3. From: vadim@cix.compulink.co.uk (Vadim Lebedev)
  4. Subject: Re: Object metamorphosis - can
  5. Reply-To: vadim@cix.compulink.co.uk
  6. Date: Wed, 19 Aug 1992 16:44:38 +0000
  7. Message-ID: <memo.584473@cix.compulink.co.uk>
  8. Sender: usenet@gate.demon.co.uk
  9. Lines: 104
  10.  
  11. In-Reply-To: <1992Aug17.223629.5722@fcom.cc.utah.edu> swillden@news.ccutah.edu (Shawn Willden)
  12.  
  13. TITLE: Object metamorphosis - can/should it be done?
  14.  
  15. In article   : <1992Aug17.223629.5722@fcom.cc.utah.edu>
  16.  swillden@news.ccutah.edu (Shawn Willden)
  17.  writes:
  18. > 
  19. > I ran across some interesting Objective-C code the other day and I 
  20. > wondered if there is some way to implement it in C++.  Then I wondered
  21. > if it was a good idea to try.  Anyway, the concept is that an object
  22. > can be asked to mutate into an object of a different type.  Under
  23. > Objective-C's concept of an object, any object can mutate to essentially
  24. > any other type because all messages are resolved at run-time.  In C++'s
  25. > static system this is not possible, however, it seems to me that there 
  26. > is at least one case in which it might be possible in C++ and maybe even 
  27. > useful.  Given a base class pointer or reference to a derived class
  28. > object, it should be possible to replace the derived class object with
  29. > an object of another derived type.  Something like:
  30. [ message deleted]
  31.  
  32. You canc achieve your goal using placement new syntax:
  33.  
  34. class Mutator { } mutator;
  35.  
  36. class Butterfly
  37.         {
  38.  protected:
  39.     // Allocate abject in-place 
  40.     void *new(size_t,  void *t)  { return t; }
  41.     
  42.     // Mutating constructor
  43.     Butterfly(Mutator , const Butterfly &) { // Do nothing here }
  44.  
  45.         // some data here.
  46.         public:
  47.  
  48.  // allocate a storage chunk capable to accomodoate all of the 
  49.  // variantes 
  50.  void *new(size_t s) {
  51.   return new char[MAX(sizeof(Pupa), sizeof(Adult), sizeof(Butterfly),s)];
  52.   }
  53.  
  54.         Butterfly()                     {...}
  55.         Butterfly(Butterfly& b)         {...}
  56.         // The metamorphose() function will turn an object of some
  57.         // descendant type into an object of some other descendant 
  58.         // type.
  59.         virtual void metamorphose() = 0;
  60.         virtual void report()           {cout << "I'm a generic butterfly\n";}
  61.         };
  62.  
  63. class Pupa : public Butterfly
  64.         {
  65.         // Note that this method is private.  This is to insure that
  66.         // it is *only* called through the base class interface. 
  67.         void metamorphose();
  68.         public:
  69.         Pupa()                  {...}
  70.         void report()           {cout << "I'm a caterpillar\n";}
  71.  protected:
  72.     // Mutating constractor
  73.     Pupa(Mutator m, const Butterfly &b) : Butterfly(m, b) { }  
  74.         };
  75.  
  76. class Adult : public Butterfly
  77.         {
  78. friend class Pupa;
  79.         // Again, this method is private.
  80.         void metamorphose();
  81.         public:
  82.         Adult()                                 {...}
  83.         Adult(Butterfly& b) : Butterfly(b)      {...}
  84.         void report()           {cout << "I'm a real butterfly\n";}
  85.  protected:
  86.     Adult(Mutator m, const Pupa &p) : Butterfly(m, p) { }  
  87.  
  88.         };
  89.  
  90. void Pupa::metamorphose()
  91.         {
  92.  new (this) Adult(mutator, *this);
  93.         }
  94.  
  95. main()
  96.         {
  97.         Butterfly *fred = new Pupa;
  98.  
  99.         fred->report();
  100.         fred->metamorphose();
  101.         fred->report();
  102.         }
  103.  
  104.  
  105. Of course this trick works only on heap allocated objects, for automatic
  106. or static objects one should take care that the base and all derived classes
  107. has the same sizes. 
  108.  
  109. -----------------------------------------------------------------------
  110. Vadim Lebedev                      |   Kortex International
  111. vadim@cix.compulink.co.uk          |   139-147 av. Paul-Vaillant Couturier
  112.                                    |   93126 La Courneuve - CEDEX, France
  113.  
  114.  
  115.