Lecture Notes for Advanced Programming II

17 April 2003 - Wrapping with Classes

Outline

• Classes

• Classes and Pointers

• Pointers in Classes

  • Constructors and Destructors

  • Copying and Assignment

  • Pointer Behavior

  • Examples

• Sharing vs. Copying

  • Implementation Changes

  • Sharing Semantics

  • Copying and Sharing

  • Examples

Classes

• C++ classes have a highly useful property:

  • Instance creation can involve calling arbitrary code.

  • Instance destruction can involve calling arbitrary code.

• This property forms the basis for much interesting software design.

  • Smart pointers.

  • The Initialization is Acquisition pattern.

Classes and Pointers

• Pointers are base types; nothing happens on creation or destruction.

Pointers in Classes

• Create a class that behaves like a pointer but manages memory correctly.

  template <typename T> 
  class Handle {
  
    T * tp
  
    public
  
      Handle()
      Handle(T *)
  
      Handle (const Handle &)
      Handle & operator = (const Handle &)
     ~Handle()
  
      operator bool() const
      T & operator * () const
      T * operator -> () const
    }
  

Constructors and Destructors

• Create an empty handle, pointing to nothing.

  template <typename T>
  Handle<T>() : tp(0) { }
  

• Create a handle pointing to something.

  template <typename T>
  Handle<T>(T * tp) : tp(tp) { }
  

• Delete whatever.

  template <typename T>
  ~Handle<T>()
    if (tp) delete tp
  

  • This is old school; you can (should?) also do

    template <typename T>
    ~Handle<T>() { delete tp }
    

  • tp can't be a pointer to an array of things.

Copying and Assignment

• How to copy the object to which tp is pointing?

  • A copy constructor isn't helpful.

  • Cast constructors aren't either.

  • Assume T does it using the clone() function.

• Copying.

  template <typename T>
  Handle<T>(const Handle & th)
    tp = th.tp ? th.tp->clone() : 0
  

• Assignment.

  template <typename T> Handle<T> & 
  Handle<T>::operator = (const Handle & rhs)
    if (&rhs != this)
      delete tp
      tp = rhs.tp ? rsh.tp->clone() : 0
  
    return *this
  

Pointer Behavior

• Null testing.

  • A null pointer is false; other pointer values are true.

    template <typename T> bool
    Handle<T>::operator bool (void) { 
      return tp 
      }
    

• Dereferencing (the follow operator).

  template <typename T> T & 
  Handle<T>::operator * (void) const
    assert(tp)
    return *tp
  

• Follow and access.

  • Not a binary operator.

  • Should return a pointer to follow and access.

    template <typename T> T * 
    Handle<T>::operator -> (void) const
      assert(tp)
      return tp
    

Example

$ cat t.cc
struct widget {

  widget(string str) : str(str)
    cerr << "Creating a " << str << " widget"

 ~widget()
    cerr << "Deleting a " << str << " widget"

  widget * clone(void) const { return 0; }

  const string str;
  };

int main() {
  handle<widget> w1h = new widget("red");
  if (w1h) {
    handle<widget> w2h = new widget("blue");
    }
  }

$ g++ -o t -ansi -pedantic -Wall t.cc

$ ./t
Creating a red widget.
Creating a blue widget.
Deleting a blue widget.
Deleting a red widget.

$ 

See the complete code.

Another Example

$ cat t.cc
struct widget
  string name;
  string type;
  widget * clone(void) const { return 0; }

std::ostream & 
operator << (ostream & os, widget w)
  return os << "A " << w.type 
            << " widget named " << w.name

int main()
  handle<widget> wh = new widget()

  wh->name = "joe"
  wh->type = "blue"

  std::cout << *wh << "\n"

$ g++ -o t -ansi -pedantic -Wall t.cc

$ ./t
A blue widget named joe

$ 

A Final Example

$ cat t.cc
struct widget
  std::string name;
  std::string type;

int main()
  handle<widget> wh = new widget();

  wh->name = "joe";
  wh->type = "blue";

  std::cout << *wh << "\n";

$ g++ -o t -ansi -pedantic -Wall t.cc
t.cc: In copy constructor 
  handle<T>::handle(const handle<T>&) 
  [with T = widget]:
t.cc:58:   instantiated from here
t.cc:16: no matching function for call to 
  widget::clone()

$ 

• The handled object needs to support clone().

Sharing vs. Copying

• Copying handle data can be expensive in time and space.

• Sharing can be cheaper in both.

• Need to watch out for pre-mature deletion.

  • Keep count of handles and delete when it's zero.

  template <typename T> 
  class Handle {
  
    T * tp
    size_t * ref_cntp;
  
    public
  
      Handle()
      Handle(T *)
  
      Handle (const Handle &)
      Handle & operator = (const Handle &)
     ~Handle()
  
      operator bool() const
      T & operator * () const
      T * operator -> () const
    }
  

Implementation Changes

• The default constructor.

  handle() : tp(0), ref_cntp(new size_t(1)) { }
  

• The cast constructor.

  handle(T * tp) 
    : tp(tp), ref_cntp(new size_t(1)) { }
  

• The destructor.

  ~handle(void)
    if (--*ref_cntp == 0)
      delete tp, ref_cntp
  

• Assignment.

  handle & operator = (const handle & th)
    ++*th.ref_cntp
    if (--*ref_cntp == 0)
      delete ref_cntp, tp
    ref_cntp = th.ref_cntp
    tp = th.tp
    return *this
  

  • This code isn't exception safe.

Sharing Semantics

• Sharing can lead to nasty behavior if unexpected.

  $ cat t.cc
  int main() 
    handle<widget> w1h = new widget()
    w1h->name = "joe"
    w1h->type = "blue"
  
    handle<widget> w2h = w1h
    w2h->type = "green"
  
    std::cout << "w1h:  " << *w1h << ".\n"
    std::cout << "w2h:  " << *w2h << ".\n"
  
  $ g++ -o t -ansi -pedantic -Wall t.cc
  
  $ ./t
  wh1:  A green widget named joe.
  wh2:  A green widget named joe.
  
  $
  

• Java has this semantics, C++ doesn't.

• Even if expected, sometimes sharing is inconvenient.

Copying and Sharing

• Provide a function to make an unshared copy of the data.

  • Java calls this the clone() function.

  template < typename T > void
  Handle<T>::clone(void)
    if (*ref_cntp != 1)
      --*ref_cntp
      ref_cntp = new size_t(1)
      if (tp)
        tp = tp->clone()
  

Example

$ cat t.cc
int
main() {
  handle<widget> w1h = new widget();
  w1h->name = "joe";
  w1h->type = "blue";

  handle<widget> w2h = w1h;
  w2h.clone();
  w2h->type = "green";

  std::cout << "w1h:  " << *w1h << ".\n";
  std::cout << "w2h:  " << *w2h << ".\n";
  }

$ g++ -o t -ansi -pedantic -Wall t.cc

$ ./t
w1h:  A blue widget named joe.
w2h:  A green widget named joe.

$ 

See the complete code.

Points to Remember

• Classes can automatically run code on entrance and exit.

• Wrapping things in classes is an important design and implementation technique.

  • Auto pointers, envelope-letter, handles.

• Memory management can use copying or sharing semantics.

  • Knowing which is being used is crucial to writing correct programs.

  • Neither is universal.

This page last modified on 14 April 2003.