Polymorphic SmartPtr

    This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

    • Polymorphic SmartPtr

      I noticed that the code that accompanies the book states that the SmartPtr implementation used in the book's code is not polymorphic. That's a real drag since polymorphism IMHO is a trait that all SmartPtr implementations should support.

      Anyway here's my SmartPtr implementation. It is modelled on the SmartPtr implementation from the book. It supports polymorphism, intrusive and non-intrusive reference counting, and correctly handles const pointer types. One thing that it doesn't currently do is correctly delete the pointer if it is an array. However this can be easily fixed by adding a Deletion policy to the SmartPtr.

      One final note: the code uses member templates so you'll need at least VC 7 to compile the code.

      Brainfuck Source Code

      1. //------------------------------------------------------------------------
      2. // $Id: smartptr.h,v 1.10 2003/11/16 07:06:48 dpoon Exp $
      3. //
      4. // Copyright (c) 2003 David Poon
      5. //
      6. // Permission is hereby granted, free of charge, to any person
      7. // obtaining a copy of this software and associated documentation
      8. // files (the "Software"), to deal in the Software without
      9. // restriction, including without limitation the rights to use,
      10. // copy, modify, merge, publish, distribute, sublicense, and/or
      11. // sell copies of the Software, and to permit persons to whom
      12. // the Software is furnished to do so, subject to the following
      13. // conditions:
      14. //
      15. // The above copyright notice and this permission notice shall be
      16. // included in all copies or substantial portions of the Software.
      17. //
      18. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      19. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      20. // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      21. // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      22. // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      23. // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      24. // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      25. // OTHER DEALINGS IN THE SOFTWARE.
      26. //------------------------------------------------------------------------
      28. #if !defined(SMARTPTR_H)
      29. #define SMARTPTR_H
      31. class RefCounted
      32. {
      33. public:
      34. RefCounted() : m_refCount(0)
      35. {
      36. }
      38. virtual ~RefCounted()
      39. {
      40. }
      42. int addRef()
      43. {
      44. return ++m_refCount;
      45. }
      47. int release()
      48. {
      49. int refCount = --m_refCount;
      51. if (refCount <= 0)
      52. delete this;
      54. return refCount;
      55. }
      57. int getRefCount() const
      58. {
      59. return m_refCount;
      60. }
      62. template <typename T>
      63. T *getPtr() const
      64. {
      65. return (T*)this;
      66. }
      68. private:
      69. int m_refCount;
      70. };
      72. //------------------------------------------------------------------------
      74. template <typename T>
      75. class RefCountedAdapter : public RefCounted
      76. {
      77. public:
      78. RefCountedAdapter(T *rhs) : m_pPointee(rhs)
      79. {
      80. }
      82. ~RefCountedAdapter()
      83. {
      84. if (getRefCount() <= 0)
      85. delete m_pPointee;
      86. }
      88. template <typename U>
      89. T *getPtr() const
      90. {
      91. return m_pPointee;
      92. }
      94. private:
      95. T *m_pPointee;
      96. };
      98. //------------------------------------------------------------------------
      100. class SmartPtrBase
      101. {
      102. public:
      103. SmartPtrBase() : m_pRefCounted(0)
      104. {
      105. }
      107. ~SmartPtrBase()
      108. {
      109. if (m_pRefCounted)
      110. m_pRefCounted->release();
      111. }
      113. RefCounted *getPtr() const
      114. {
      115. return m_pRefCounted;
      116. }
      118. protected:
      119. RefCounted *m_pRefCounted;
      120. };
      122. //------------------------------------------------------------------------
      124. template <typename T>
      125. class SmartPtr : public SmartPtrBase
      126. {
      127. public:
      128. SmartPtr()
      129. {
      130. }
      132. SmartPtr(SmartPtr<T> &rhs)
      133. {
      134. assign(rhs);
      135. }
      137. SmartPtr(RefCounted *rhs)
      138. {
      139. assign(rhs);
      140. }
      142. SmartPtr(SmartPtrBase &rhs)
      143. {
      144. assign(rhs);
      145. }
      147. SmartPtr(T *rhs)
      148. {
      149. assign(rhs);
      150. }
      152. SmartPtr &operator=(SmartPtr<T> &rhs)
      153. {
      154. if (!m_pRefCounted)
      155. {
      156. assign(rhs);
      157. }
      158. else
      159. {
      160. if (m_pRefCounted->getPtr<T>() != rhs.m_pRefCounted->getPtr<T>())
      161. assign(rhs);
      162. }
      164. return *this;
      165. }
      167. SmartPtr &operator=(RefCounted *rhs)
      168. {
      169. if (!m_pRefCounted)
      170. {
      171. assign(rhs);
      172. }
      173. else
      174. {
      175. if (m_pRefCounted->getPtr<T>() != rhs->getPtr<T>())
      176. assign(rhs);
      177. }
      179. return *this;
      180. }
      182. SmartPtr &operator=(SmartPtrBase &rhs)
      183. {
      184. if (!m_pRefCounted)
      185. {
      186. assign(rhs);
      187. }
      188. else
      189. {
      190. if (m_pRefCounted->getPtr<T>() != rhs.getPtr()->getPtr<T>())
      191. assign(rhs);
      192. }
      194. return *this;
      195. }
      197. SmartPtr &operator=(T *rhs)
      198. {
      199. if (!m_pRefCounted)
      200. {
      201. assign(rhs);
      202. }
      203. else
      204. {
      205. if (m_pRefCounted->getPtr<T>() != rhs)
      206. assign(rhs);
      207. }
      209. return *this;
      210. }
      212. template <typename U>
      213. operator SmartPtr<U>()
      214. {
      215. return SmartPtr<U>(m_pRefCounted);
      216. }
      218. ~SmartPtr()
      219. {
      220. }
      222. T *operator->() const
      223. {
      224. return m_pRefCounted->getPtr<T>();
      225. }
      227. T &operator*() const
      228. {
      229. return *m_pRefCounted->getPtr<T>();
      230. }
      232. bool operator!() const
      233. {
      234. return m_pRefCounted->getPtr<T>() == 0;
      235. }
      237. bool operator==(SmartPtrBase &rhs) const
      238. {
      239. return m_pRefCounted->getPtr<T>() == rhs.getPtr()->getPtr<T>();
      240. }
      242. bool operator!=(SmartPtrBase &rhs) const
      243. {
      244. return m_pRefCounted->getPtr<T>() != rhs.getPtr()->getPtr<T>();
      245. }
      247. private:
      248. void assign(SmartPtr<T> &rhs)
      249. {
      250. if (m_pRefCounted)
      251. m_pRefCounted->release();
      253. m_pRefCounted = rhs.m_pRefCounted;
      255. if (m_pRefCounted)
      256. m_pRefCounted->addRef();
      257. }
      259. void assign(RefCounted *rhs)
      260. {
      261. if (m_pRefCounted)
      262. m_pRefCounted->release();
      264. m_pRefCounted = rhs;
      266. if (m_pRefCounted)
      267. m_pRefCounted->addRef();
      268. }
      270. void assign(SmartPtrBase &rhs)
      271. {
      272. if (m_pRefCounted)
      273. m_pRefCounted->release();
      275. m_pRefCounted = rhs.getPtr();
      277. if (m_pRefCounted)
      278. m_pRefCounted->addRef();
      279. }
      281. void assign(T *rhs)
      282. {
      283. if (m_pRefCounted)
      284. m_pRefCounted->release();
      286. if (rhs != 0)
      287. {
      288. m_pRefCounted = new RefCountedAdapter<T>(rhs);
      289. m_pRefCounted->addRef();
      290. }
      291. }
      292. };
      294. #endif
      Display All


      Here's a little test application that should hopefully illustrate how to use my SmartPtr implementation. Notice that you shouldn't use RefCountedAdapter at all in your code - this class is used internally by the SmartPtr class for those pointer types that do not inherit from the RefCounted base class.

      C Source Code

      1. #if defined(_DEBUG)
      2. # define CRTDBG_MAP_ALLOC
      3. # include <crtdbg.h>
      4. #endif
      6. #include <iostream>
      7. #include "smartptr.h"
      9. class Base : public RefCounted
      10. {
      11. public:
      12. Base()
      13. {
      14. std::cout << "Base::Base()" << std::endl;
      15. }
      17. ~Base()
      18. {
      19. std::cout << "Base::~Base()" << std::endl;
      20. }
      22. void message() const
      23. {
      24. std::cout << "Base::message()" << std::endl;
      25. }
      26. };
      28. class Derived : public Base
      29. {
      30. public:
      31. Derived()
      32. {
      33. std::cout << "Derived::Derived()" << std::endl;
      34. }
      36. ~Derived()
      37. {
      38. std::cout << "Derived::~Derived()" << std::endl;
      39. }
      40. };
      42. void TestSmartPtr()
      43. {
      44. SmartPtr<Derived> pDerived;
      45. SmartPtr<const Base> pBase;
      47. pDerived = new Derived;
      48. pBase = pDerived;
      50. if (!pDerived)
      51. {
      52. std::cout << "SmartPtr<Derived> is NULL" << std::endl;
      53. }
      54. else
      55. {
      56. pDerived->message();
      57. (*pDerived).message();
      59. if (pDerived != pBase)
      60. std::cout << "SmartPtr<Derived> != SmartPtr<Base>" << std::endl;
      62. if (!(pDerived == pBase))
      63. std::cout << "SmartPtr<Derived> != SmartPtr<Base>" << std::endl;
      64. }
      65. }
      67. int main()
      68. {
      69. #if defined(_DEBUG)
      70. _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
      71. #endif
      73. TestSmartPtr();
      75. std::cout << "Press enter to continue...";
      76. std::cin.get();
      78. return 0;
      79. }
      Display All

      The post was edited 2 times, last by dpoon ().

    • RE: Polymorphic SmartPtr

      Looks cool - by any chance did you try to replace the SmartPtr code given out with the source code???
      Mr.Mike
      Author, Programmer, Brewer, Patriot

    • RE: Polymorphic SmartPtr

      Hey dpoon,

      I get errors with the following:

      C Source Code

      1. #include <iostream>
      2. #include "smartptr.h"
      4. // BASE WEAPON CLASS
      5. class CWeapon_Data
      6. {
      7. public:
      8. // Constructor & Destructor
      9. CWeapon_Data()
      10. {
      11. std::cout<<"CWeapon_Data::CWeapon_Data()"<<std::endl;
      12. }
      14. virtual ~CWeapon_Data()
      15. {
      16. std::cout<<"CWeapon_Data::~CWeapon_Data()"<<std::endl;
      17. }
      19. // Methods
      20. virtual void vDamageMessage()
      21. {
      22. std::cout<<"CWeapon_Data::vDamageMessage()"<<std::endl;
      23. }
      25. // Members
      26. int m_iBaseDamage;
      27. int m_iWieldStr;
      28. int m_iWeight;
      29. bool m_bOneHanded;
      30. bool m_bWielded;
      31. };
      33. // DERIVED SWORD CLASS
      34. class CSword_Data : public CWeapon_Data
      35. {
      36. public:
      37. // Constructor & Destructor
      38. CSword_Data()
      39. {
      40. std::cout<<"CSword_Data::CSword_Data()"<<std::endl;
      41. }
      43. virtual ~CSword_Data()
      44. {
      45. std::cout<<"CSword_Data::~CSword_Data()"<<std::endl;
      46. }
      48. // Methods
      49. virtual void vDamageMessage()
      50. {
      51. std::cout<<"CSword_Data::vDamageMessage()"<<std::endl;
      52. }
      54. // Members
      56. };
      58. void TestSmartPtr()
      59. {
      60. SmartPtr<CSword_Data> BaseSword = new CSword_Data;
      61. SmartPtr<CWeapon_Data> BaseWeapon = new CWeapon_Data;
      63. BaseWeapon = BaseSword;
      65. if (!BaseSword)
      66. {
      67. std::cout<<"BaseSword<Derived> NULL"<<std::endl;
      68. }
      69. else
      70. {
      71. BaseSword->vDamageMessage();
      72. }
      73. }
      75. int main()
      76. {
      77. TestSmartPtr();
      79. std::cout << "Press enter to continue...";
      80. std::cin.get();
      82. return 0;
      83. }
      Display All


      An exception is thrown... I forget which one...

      Also, if instead I try and run the following:

      Source Code

      1. int main(void)
      2. {
      3. SmartPtr<CShortSword_Data> BaseShortSword = new CShortSword_Data;
      4. SmartPtr<CShortSword_Data> Base2 = new CShortSword_Data;
      6. Base2 = BaseShortSword; // Releases one
      8. SmartPtr<CSword_Data> BaseSword = BaseShortSword;
      10. SmartPtr<CWeapon_Data> BaseWeapon = BaseSword;
      12. Base2->vDamageMessage();
      13. BaseSword->vDamageMessage();
      14. BaseWeapon->vDamageMessage();
      16. return EXIT_SUCCESS;
      17. }
      Display All


      Here a Run-Time error is thrown as it can't equate one to the other, maybe all you need is a static_cast... not sure. Additionally, I noticed that in the above code when I do Base2 = BaseShortSword it does not Release Base2 as it should instead it makes a copy of it... this is very bad for memory management. One should be deleted and the other ptr rereferenced and AddRef() incremented.

      Nos

      The post was edited 1 time, last by Nostrademous ().

    • RE: Polymorphic SmartPtr

      Yeah I noticed those bugs as well :D
      I ran your code on a later version of the SmartPtr template class and I get this:

      Source Code

      1. CWeapon_Data::CWeapon_Data()
      2. CSword_Data::CSword_Data()
      3. CWeapon_Data::CWeapon_Data()
      4. CWeapon_Data::~CWeapon_Data()
      5. CSword_Data::vDamageMessage()
      6. CSword_Data::~CSword_Data()
      7. CWeapon_Data::~CWeapon_Data()
      8. Press enter to continue...


      Looking at the code you provided, this appears to be the expected behaviour.
      You didn't provide enough of the second code snippet for me to rerun that test.

      Anyway, here's an updated version of the SmartPtr template class.

      Brainfuck Source Code

      1. //------------------------------------------------------------------------
      2. // $Id: smartptr.h,v 1.11 2003/11/18 10:33:31 dpoon Exp $
      3. //
      4. // Copyright (c) 2003 David Poon
      5. //
      6. // Permission is hereby granted, free of charge, to any person
      7. // obtaining a copy of this software and associated documentation
      8. // files (the "Software"), to deal in the Software without
      9. // restriction, including without limitation the rights to use,
      10. // copy, modify, merge, publish, distribute, sublicense, and/or
      11. // sell copies of the Software, and to permit persons to whom
      12. // the Software is furnished to do so, subject to the following
      13. // conditions:
      14. //
      15. // The above copyright notice and this permission notice shall be
      16. // included in all copies or substantial portions of the Software.
      17. //
      18. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      19. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      20. // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      21. // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      22. // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      23. // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      24. // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      25. // OTHER DEALINGS IN THE SOFTWARE.
      26. //------------------------------------------------------------------------
      28. #if !defined(SMARTPTR_H)
      29. #define SMARTPTR_H
      31. template <typename T>
      32. class RefCounted
      33. {
      34. public:
      35. RefCounted(T *pPointee = 0) : m_refCount(0), m_pPointee(pPointee)
      36. {
      37. }
      39. ~RefCounted()
      40. {
      41. if (getRefCount() > 0)
      42. release();
      43. }
      45. void addRef()
      46. {
      47. ++m_refCount;
      48. }
      50. void release()
      51. {
      52. if (--m_refCount <= 0)
      53. {
      54. delete m_pPointee;
      55. m_pPointee = 0;
      56. delete this;
      57. }
      58. }
      60. int getRefCount() const
      61. {
      62. return m_refCount;
      63. }
      65. T *getPointee() const
      66. {
      67. return m_pPointee;
      68. }
      70. private:
      71. int m_refCount;
      72. T *m_pPointee;
      73. };
      75. //------------------------------------------------------------------------
      77. class SmartPtrBase
      78. {
      79. public:
      80. SmartPtrBase() : m_pRefCounted(0)
      81. {
      82. }
      84. ~SmartPtrBase()
      85. {
      86. }
      88. bool isNull() const
      89. {
      90. return m_pRefCounted == 0;
      91. }
      93. template <typename T>
      94. RefCounted<T> *getRefCounted() const
      95. {
      96. return reinterpret_cast<RefCounted<T>*>(m_pRefCounted);
      97. }
      99. protected:
      100. template <typename T>
      101. void setRefCounted(RefCounted<T> *pRefCounted)
      102. {
      103. m_pRefCounted = pRefCounted;
      104. }
      106. private:
      107. void *m_pRefCounted;
      108. };
      110. //------------------------------------------------------------------------
      112. template <typename T>
      113. class SmartPtr : public SmartPtrBase
      114. {
      115. public:
      116. SmartPtr()
      117. {
      118. }
      120. SmartPtr(SmartPtr<T> &rhs)
      121. {
      122. assign(rhs);
      123. }
      125. SmartPtr(SmartPtrBase &rhs)
      126. {
      127. assign(rhs);
      128. }
      130. SmartPtr(T *rhs)
      131. {
      132. assign(rhs);
      133. }
      135. SmartPtr &operator=(SmartPtr<T> &rhs)
      136. {
      137. if (isNull())
      138. {
      139. assign(rhs);
      140. }
      141. else
      142. {
      143. if (getRefCounted<T>()->getPointee() != rhs.getRefCounted<T>()->getPointee())
      144. assign(rhs);
      145. }
      147. return *this;
      148. }
      150. SmartPtr &operator=(SmartPtrBase &rhs)
      151. {
      152. if (isNull())
      153. {
      154. assign(rhs);
      155. }
      156. else
      157. {
      158. if (getRefCounted<T>()->getPointee() != rhs.getRefCounted<T>()->getPointee())
      159. assign(rhs);
      160. }
      162. return *this;
      163. }
      165. SmartPtr &operator=(T *rhs)
      166. {
      167. if (isNull())
      168. {
      169. assign(rhs);
      170. }
      171. else
      172. {
      173. if (getRefCounted<T>()->getPointee() != rhs)
      174. assign(rhs);
      175. }
      177. return *this;
      178. }
      180. template <typename U>
      181. operator SmartPtr<U>()
      182. {
      183. return SmartPtr<U>(getRefCounted<T>());
      184. }
      186. ~SmartPtr()
      187. {
      188. if (!isNull())
      189. getRefCounted<T>()->release();
      190. }
      192. T *operator->() const
      193. {
      194. return getRefCounted<T>()->getPointee();
      195. }
      197. T &operator*() const
      198. {
      199. return *getRefCounted<T>()->getPointee();
      200. }
      202. bool operator!() const
      203. {
      204. if (isNull())
      205. return true;
      207. return getRefCounted<T>()->getPointee() == 0;
      208. }
      210. bool operator==(SmartPtrBase &rhs) const
      211. {
      212. return getRefCounted<T>()->getPointee() == rhs.getRefCounted<T>()->getPointee();
      213. }
      215. bool operator!=(SmartPtrBase &rhs) const
      216. {
      217. return getRefCounted<T>()->getPointee() != rhs.getRefCounted<T>()->getPointee();
      218. }
      220. private:
      221. void assign(SmartPtr<T> &rhs)
      222. {
      223. if (!isNull())
      224. getRefCounted<T>()->release();
      226. setRefCounted(rhs.getRefCounted<T>());
      228. if (!isNull())
      229. getRefCounted<T>()->addRef();
      230. }
      232. void assign(SmartPtrBase &rhs)
      233. {
      234. if (!isNull())
      235. getRefCounted<T>()->release();
      237. setRefCounted<T>(rhs.getRefCounted<T>());
      239. if (!isNull())
      240. getRefCounted<T>()->addRef();
      241. }
      243. void assign(T *rhs)
      244. {
      245. if (!isNull())
      246. getRefCounted<T>()->release();
      248. if (rhs != 0)
      249. {
      250. setRefCounted<T>(new RefCounted<T>(rhs));
      251. getRefCounted<T>()->addRef();
      252. }
      253. }
      254. };
      256. #endif
      Display All


      Note that in this version I have cleaned up the design so that the only class you should be using is the SmartPtr template class. The other two classes are used to implement SmartPtr.

      The post was edited 1 time, last by dpoon ().

    • Just a quick aside - the 2nd edition source code uses Boost's shared_ptr template, which is polymorphic and quite easy to use.
      Mr.Mike
      Author, Programmer, Brewer, Patriot