Re: About cloning

In article <4593232f$0$19281$426a34cc@news.free.fr>, Mathias Gaunard
<loufoque@remove.gmail.com> wrote:


.....


I use a reference count, and a class maintaining a polymorphic pointer.
This way, one can choose between cloning and handing over references. The
reference count may not deallocate properly in circular references,
though.

template<class A>
class ref {
protected:
  mutable A* data_;
  static typename A::null_type null_;

public:
  typedef A& reference;
  typedef A* pointer;
  typedef const A& const_reference;
  typedef const A* const_pointer;

  typedef ref<A> This;

  ref() : data_(0) {}
  ~ref() { shed(); }

  ref(const ref& x) : data_(x.copy()) {}
  ref& operator=(const ref& x) {
    if (data_ != x.data_) { shed(); data_ = x.copy(); }
    return *this;
  }

  // Conversion constructors.
  ref(A* ap) : data_(ap) {}
  ref(const A* ap) : data_(ap->copy()) {}
  ref(const A& a) : data_(a.copy()) {}

  template<class B>
  explicit ref(B* bp, bool dynamic = true)
   : data_(dynamic? dynamic_cast<A*>(bp) : static_cast<A*>(bp)) {}

  template<class B>
  explicit ref(const B& br, bool dynamic = true)
   : data_(dynamic? dynamic_cast<A*>(br.copy()) : static_cast<A*>(br.copy())) {}

  ref<A> clone() const { return (data_ == 0)? 0 : data_->clone(); }
  A* copy() const { return (data_ == 0)? 0 : data_->copy(); }

  void shed() { if (data_ != 0) data_->shed(); }

  bool is_null() const { return (data_ == 0); }

  // Operators that return pointer 0 when applicable:

  operator A*() { return data_; }
  operator const A*() const { return data_; }

  // Operators that return reference to an object A() when applicable:

  // Return a pointer to the referenced object, or if 0, the A::null_ object:
  A* operator->() { if (data_ == 0) return &null_; else return data_; }
  const A* operator->() const { if (data_ == 0) return &null_; else return
data_; }

  // Return a reference to the referenced object, or if 0, the A::null_ object:
  A& operator*() { if (data_ == 0) return null_; else return *data_; }
  const A& operator*() const { if (data_ == 0) return null_; else return
*data_; }

  // Create an independent copy of the referenced object.
  ref<A> detach() const {
    if (data_ != 0 && data_->count() > 1) { data_->shed(); data_ =
data_->clone(); }
    return copy();
  }

  // If 0, mutate to new A(). Return a reference to an independent copy of the
  // referenced object.
  A& operator+() const {
    if (data_ == 0) data_ = new A();
    else if (data_->count() > 1) { data_->shed(); data_ = data_->clone(); }
    return *data_;
  }
};

template<class A, class B>
A* cast_pointer(ref<B>& ar) { return dynamic_cast<A*>((B*)ar); }

template<class A, class B>
const A* cast_pointer(const ref<B>& ar) { return dynamic_cast<const
A*>((const B*)ar); }

template<class A, class B>
A& cast_reference(ref<B>& ar) { return dynamic_cast<A&>(*(B*)ar); }

template<class A, class B>
const A& cast_reference(const ref<B>& ar) { return dynamic_cast<const
A&>(*(const B*)ar); }

#define ref_null(A) template <> A::null_type ref<A>::null_ = A::null_type()

// Use the clone_declare/clone_source if clone he
#define clone_class(A) virtual A* clone() const { return new A(*this); }
#define copy_class(A) virtual A* copy() const { increment_count(); return
const_cast<A*>(this); }

#define clone_declare(A) virtual A* clone() const
#define clone_source(A) A* A::clone() const { return new A(*this); }

#define copy_declare(A) virtual A* copy() const
#define copy_source(A) A* A::copy() const { increment_count(); return
const_cast<A*>(this); }

template<class A>
inline std::istream& operator>>(std::istream& is, ref<A>& a) {
  return is >> (*a);
}

template<class A>
inline std::ostream& operator<<(std::ostream& os, const ref<A>& a) {
  return os << (*a);
}

template<class A>
inline relation compare(const ref<A>& x, const ref<A>& y) {
  return compare(*x, *y);
}

template<class A>
inline relation total(const ref<A>& x, const ref<A>& y) {
  return total(*x, *y);
}

template<class A>
inline bool operator==(const ref<A>& x, const ref<A>& y) {
  return (*x == *y);
}

template<class A>
inline bool operator!=(const ref<A>& x, const ref<A>& y) {
  return (*x != *y);
}

template<class A>
inline bool operator<(const ref<A>& x, const ref<A>& y) {
  return (*x < *y);
}

template<class A>
inline bool operator<=(const ref<A>& x, const ref<A>& y) {
  return (*x <= *y);
}

template<class A>
inline bool operator>(const ref<A>& x, const ref<A>& y) {
  return (*x > *y);
}

template<class A>
inline bool operator>=(const ref<A>& x, const ref<A>& y) {
  return (*x >= *y);
}

template<class A>
inline ref<A> operator+(const ref<A>& x, const ref<A>& y) {
  return (*x + *y);
}

template<class A>
inline ref<A> operator*(const ref<A>& x, const ref<A>& y) {
  return ((*x) * (*y));
}

class object {
  typedef unsigned long count_type;
  mutable count_type count_;
public:
  typedef object null_type;

  object() : count_(1) {}
  virtual ~object() {}
  
  object(const object&) : count_(1) {}

  void increment_count() const { ++count_; }
  count_type count() const { return count_; }

  clone_declare(object);
  copy_declare(object);

  void shed() { if (--count_ == 0) delete this; }

  virtual void write(std::ostream& os, write_style) const { os << "object"; }
};

inline std::ostream& operator<<(std::ostream& os, const object& a) {
  a.write(os, write_default); return os;
}

// Defines behavior of my():
class my_null;

  // My derived class:
class my : public object {
public:
  typedef unsigned long size_type;
  typedef formula_null null_type;

  clone_declare(formula) = 0;
  copy_declare(formula) = 0;

  ...
};

class formula_null : public formula {
public:
  clone_declare(formula_null);
  copy_declare(formula_null);

  ...
};

Then create a polymorphic variable using ref<my>. If you do not need
special behavior of my(), eliminate the 'null' stuff; I only used it to
convert a project. Properly, the class object should be derived as
virtual, but then one cannot use static_vast, and each dynamic conversion
will take up perhaps some tens of cycles. So it it seems better to drop
it, and avoiding multiple inheritance of 'object' by hand.

--
  Hans Aberg

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]