gcc/testsuite/g++.old-deja/g++.benjamin/tem01.C

   1 // { dg-do assemble  }
   2 // prms-id: 13911
   3
   4 template<unsigned int N>
   5 class ref_counter {
   6 public:
   7   ref_counter() : p_refcnt(new unsigned int(N)) {}
   8   ref_counter(const ref_counter<N>& x) : p_refcnt(x.p_refcnt) {
   9     ++*p_refcnt;
  10   }
  11   ref_counter& operator=(const ref_counter<N>& rhs) {
  12     ++*rhs.p_refcnt;
  13     decrement();
  14     p_refcnt = rhs.p_refcnt;
  15     return *this;
  16   }
  17   ~ref_counter() {decrement();}
  18
  19   bool unique() const {return *p_refcnt == N;}
  20
  21 private:
  22   unsigned int* p_refcnt;
  23   void decrement() {
  24     if (unique()) delete p_refcnt;
  25     else --*p_refcnt;
  26   }
  27 };
  28
  29 template<class T, unsigned int N>
  30 class ref_pointer {
  31 public:
  32
  33   ref_pointer() : the_p(0) {}
  34   ref_pointer(T* just_newed) : the_p(just_newed) {}
  35   virtual ~ref_pointer() {if (unique()) delete the_p;}
  36 protected:
  37   ref_pointer(T* the_p_arg, ref_counter<N>& ref_count_arg)
  38     : the_p(the_p_arg), ref_count(ref_count_arg) {}
  39
  40 public:
  41
  42   ref_pointer& operator=(const ref_pointer&);
  43   ref_pointer& operator=(T*);
  44   operator const T*() const {return the_p;}
  45   T* operator()() {return the_p;}
  46   T* operator()() const {return the_p;}
  47   T& operator*() const {return *the_p;}
  48   friend bool operator==(const ref_pointer<T, N>& lhs,
  49                          const ref_pointer<T, N>& rhs) {
  50     return lhs.the_p == rhs.the_p;
  51   }
  52   friend bool operator!=(const ref_pointer<T, N>& lhs,
  53                          const ref_pointer<T, N>& rhs) {
  54     return lhs.the_p != rhs.the_p;
  55   }
  56
  57
  58   bool unique() const {return ref_count.unique();}
  59   bool isNull() const {return the_p==0;}
  60
  61 protected:
  62   ref_counter<N>& refCount() {return ref_count;}
  63
  64 private:
  65
  66   ref_counter<N> ref_count;
  67   T* the_p;
  68 };
  69
  70 template<class T, unsigned int N>
  71 ref_pointer<T, N>& ref_pointer<T, N>::operator=(const ref_pointer<T, N>& rhs) {
  72   if (the_p != rhs.the_p) {
  73     if (unique()) delete the_p;
  74     the_p = rhs.the_p;
  75     ref_count = rhs.ref_count;
  76   }
  77   return *this;
  78 }
  79
  80
  81 template<class T, unsigned int N>
  82 ref_pointer<T, N>& ref_pointer<T, N>::operator=(T* just_newed) {
  83   if (unique()) delete the_p;
  84   the_p = just_newed;
  85   ref_count = ref_counter<N>();
  86   return *this;
  87 }
  88
  89
  90
  91 template<class T>
  92 class CountedObjPtr : public ref_pointer<T, 1> {
  93 public:
  94   CountedObjPtr() {}
  95   CountedObjPtr(T* just_newed) : ref_pointer<T, 1>(just_newed) {}
  96   CountedObjPtr(T* the_p_arg, ref_counter<1>& ref_count_arg)
  97     : ref_pointer<T, 1>(the_p_arg, ref_count_arg) {}
  98   CountedObjPtr<T>& operator=(T* rhs) {
  99     ref_pointer<T, 1>::operator=(rhs);
 100     return *this;
 101   }
 102   CountedObjPtr<T>& operator=(const CountedObjPtr<T>& rhs) {
 103     ref_pointer<T, 1>::operator=(rhs);
 104     return *this;
 105   }
 106   T* operator->() const {return (*this)();}
 107
 108 };
 109
 110
 111
 112
 113
 114 //instantiating type
 115
 116 class TSObservable;
 117
 118 class TSObserver {
 119 public:
 120
 121   enum TSType { NormalTS, UpYldCrvTS, DownYldCrvTS, ZeroVolTS };
 122
 123   virtual ~TSObserver() {}
 124
 125   virtual void update(TSObservable* theChangedObservable) = 0;
 126   virtual TSType key() const { return myKey; }
 127   virtual TSType& key() { return myKey; }
 128 protected:
 129   TSObserver(TSType myKeyArg) : myKey(myKeyArg) {}
 130   TSType myKey;
 131 };
 132
 133
 134
 135 //now try to instantiate
 136 template class CountedObjPtr<TSObserver>;