This post originated from an RSS feed registered with Java Buzz by noe casas. Original Post: operator->() ad infinitum Feed Title: SoftwareDesignStuff Feed URL: http://feeds2.feedburner.com/softwaredesignstuff Feed Description: This blog is a place to share my ideas and opinions on topics like software design, good/bad programming practices, design patterns, programming languages, frameworks, software technology and so on, and to discuss them with you. Latest Java Buzz Posts Latest Java Buzz Posts by noe casas Latest Posts From SoftwareDesignStuff

template <typename T>
class MySmartPointer {
 public:
   MySmartPointer(T* pointee) : pointee_(pointee) {}

   T* operator->() { return pointee_; }

   /* some magic here... */

 private:
   T* pointee_;
};

MyClass* x (new MyClass);
x->doStuff();

MySmartPointer <MyClass> y (new MyClass);
y->doStuff();

struct Baz {
 void sayHello() { cout << "hello" <<>() { return baz_; }
};
struct Bar {
  Baz* baz_;
  Baz* operator->() { return baz_; }
};
struct Foo {
 Bar bar_;
 Bar operator->() { return bar_; }
};

void doStuff () {
 Foo foo;
 foo->sayHello();
}

void doStuff () {
 Foo foo;
 Bar bar (foo.operator->());
 Baz* baz = bar.operator->();
 baz->sayHello();
}

template<typename T>
class LockSmartPtrAux {
 public:
   LockSmartPtrAux(T* t, Lock& lock)
         : t_(t), lock_(lock) {
       lock_.lock();  /* lock at creation */
   }
   ~LockSmartPtrAux() {
       lock_.unlock(); /* unlock at destruction */
   }
   T* operator->() { return t_; }
 private:
   T* t_;
   Lock& lock_;
};

template<typename T>
class LockSmartPtr {
 public:
  LockSmartPtr(T* t) : t_(t) {}
  LockSmartPtrAux<T> operator->() {
    return LockSmartPtrAux<T>(t_, lock_);
  }
 private:
   T* t_;
   Lock lock_;
};
// LockSmartPtrAux should be declared inside LockSmartPtr to enhance symbol locality

map<string, MyClass> cache;
/* fill cache with useful and hard to build stuff... */ 
LockSmartPtr<map<string,MyClass> > threadsafeCache(&cache);
doSomethingInAnotherThread1 (threadsafeCache);
doSomethingInAnotherThread2 (threadsafeCache);

• To just perform some action (e.g. lock_.lock() ) BEFORE the "intercepted" call, you don't need an extra auxiliary object (e.g. LockSmartPtrAux), but only to invoke it before returning the pointee.


• However, to perform some action (e.g. lock_.unlock() ) just AFTER the intercepted call and before the return, you have to place that action in the destructor of an auxiliary object and use operator-> trick.