home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1993 #1 / NN_1993_1.iso / spool / comp / lang / cplus / 18943 < prev    next >
Encoding:
Text File  |  1993-01-11  |  3.0 KB  |  95 lines
  1. Newsgroups: comp.lang.c++
  2. Path: sparky!uunet!brunix!brunix!sdm
  3. From: sdm@cs.brown.edu (Scott Meyers)
  4. Subject: Re: Preventing inheritance
  5. Message-ID: <1993Jan11.154735.17187@cs.brown.edu>
  6. Sender: news@cs.brown.edu
  7. Organization: Brown University Department of Computer Science
  8. References: <1iqtnpINN283@news.cerf.net>
  9. Date: Mon, 11 Jan 1993 15:47:35 GMT
  10. Lines: 83
  11.  
  12. In article <1iqtnpINN283@news.cerf.net> hlf@nic.cerf.net (Howard Ferguson) writes:
  13. | 
  14. | If I create a class which I am supplying to other users, how do I
  15. | make sure that they do not inherit from it ever. I could overload new
  16. | and check the size of the object that is being allocated, but there
  17. | are two catchs. The first minor one is that this is a run-time check,
  18. | and it would be far preferable to catch this sort of thing at compile
  19. | time. More seriously, they could over-ride the new operator and by-pass
  20. | the check.
  21.  
  22. More seriously still, not all objects are allocated on the heap, so new
  23. isn't always called. 
  24.  
  25. The solution to your problem sort of depends on whether you want to prevent
  26. actual derivation or "moral" derivation.  If you only want to prevent
  27. actual derivation, make everything in the class private and then create a
  28. second class which is a friend to the first one:
  29.  
  30.   class StandAlone {      // nobody should derive from this class
  31.     private:
  32.        int x, y, z;
  33.     
  34.         StandAlone();
  35.         ~StandAlone();
  36.         void foo();
  37.         int bar() const;
  38.  
  39.     friend class UseMe;   // this is the class clients actually use
  40.   };
  41.  
  42. UseMe contains an instance of StandAlone, and calls to functions in UseMe
  43. are just forwarded to this object:
  44.  
  45.   class UseMe {
  46.     private:
  47.       StandAlone s;
  48.  
  49.     public:
  50.         UseMe() {}
  51.         ~UseMe() {}
  52.         void foo() { s.foo(); }
  53.         int bar() const { return s.bar(); }
  54.   };
  55.  
  56. You get extra style points for nesting StandAlone inside UseMe.  If you do,
  57. not that StandAlone's members still need to be private, otherwise friends
  58. of UseMe would have access to StandAlone.
  59.  
  60. There are two problems with this approach.  First, it's not utterly
  61. iron-clad, because UseMe can still derive from StandAlone, like this:
  62.  
  63.   class UseMe {
  64.     class Nested: public StandAlone { ... };
  65.   };
  66.  
  67. Second, it doesn't prevent "moral" derivation:  clients can still use UseMe
  68. as a base class, and you may not want that.
  69.  
  70. A different -- substantially less direct -- approach to the problem is to
  71. just declare Standalone in the usual manner, but without any virtual
  72. functions:
  73.  
  74.   class StandAlone {      // nobody should derive from this class
  75.     private:
  76.        int x, y, z;
  77.     
  78.     public:
  79.         StandAlone();
  80.         ~StandAlone();
  81.         void foo();
  82.         int bar() const;
  83.   };
  84.  
  85. Because none of the functions is declare virtual -- notably the destructor
  86. -- you might hope that clients catch on that this class is not designed for
  87. use as a base class.  Unfortunately, that's the only thing you've got going
  88. for you in this case: hope.
  89.  
  90. Scott
  91.  
  92.  
  93. -------------------------------------------------------------------------------
  94. What do you say to a convicted felon in Providence?  "Hello, Mr. Mayor."
  95.