zeus

0 #include <iostream>

1 #include <utility>

2

3 template <class T> struct DeleteByOperator {

4 template <class U> using rebind = DeleteByOperator<U>;

5

6 void operator()(T *p) const { delete p; }

7 };

8

9 template <class P> struct NoRelease {

10 template <class U> using rebind = NoRelease<U>;

11 };

12

13 struct NoDebug {

14 template <class T> static void constructed(const T *p) {}

15 template <class T> static void deleted(const T *p) {}

16 };

17

18 template <class T, class DeletionPolicy = DeleteByOperator<T>,

19 template <class...> class ReleasePolicy = NoRelease,

20 class DebugPolicy = NoDebug>

21 class SmartPtr

22 : private DeletionPolicy,

23 public ReleasePolicy<SmartPtr<T, DeletionPolicy, ReleasePolicy>> {

24 T *m_p;

25

26 public:

27 using deletion_policy = DeletionPolicy;

28 using release_policy =

29 ReleasePolicy<SmartPtr<T, DeletionPolicy, ReleasePolicy>>;

30 using debug_policy = DebugPolicy;

31

32 explicit SmartPtr(T *p = nullptr,

33 DeletionPolicy &&deletion_policy = DeletionPolicy())

34 : DeletionPolicy(std::move(deletion_policy)), m_p(p) {

35 DebugPolicy::constructed(m_p);

36 }

37

38 ~SmartPtr() {

39 DebugPolicy::deleted(m_p);

40 DeletionPolicy::operator()(m_p);

41 }

42

43 template <typename U>

44 using rebind = SmartPtr<U, typename DeletionPolicy::template rebind<U>,

45 ReleasePolicy, DebugPolicy>;

46 };

47

48 template <class P> struct WithRelease {

49 template <class U> using rebind = WithRelease<U>;

50

51 void release() { static_cast<P *>(this)->m_p = nullptr; }

52 };

53

54 struct Debug {

55 template <class T> static void constructed(const T *p) {

56 std::cout << "Constructed SmartPtr for object"

57 << static_cast<const void *>(p) << std::endl;

58 }

59

60 template <class T> static void deleted(const T *p) {

61 std::cout << "Deleted SmartPtr for object" << static_cast<const void *>(p)

62 << std::endl;

63 }

64 };

65

66 int main() {

67 const auto p = SmartPtr(new int(5));

68

69 return 0;

70 }