Simple Synchronized Statement in C++

s.cc

#include <iostream>
#include <pthread.h>
using namespace std;

class ScopedLock {
public:
  ScopedLock(pthread_mutex_t & m): mp(&m){
    pthread_mutex_lock(mp);
  };
  ~ScopedLock(){
    pthread_mutex_unlock(mp);
  }
  pthread_mutex_t * mp;
};

template <typename T>
class Syncronized {
public:
  Syncronized(T* t): ptr(t){
    pthread_mutex_init(&m,NULL);
  };
  ~Syncronized(){
    pthread_mutex_destroy(&m);
    if(ptr != NULL) delete ptr;
  };
  T & i(){
    return *ptr;
  };
  pthread_mutex_t m;
private:
  Syncronized():ptr(NULL){
    pthread_mutex_init(&m,NULL);
  };
  T * ptr;
};

#define SYNCRONIZED(OBJ,STATEMENT) \
  { ScopedLock ___sl_OBJ ((OBJ)->m); {STATEMENT}; };


class ScopedRDLock {
public:
  ScopedRDLock(pthread_rwlock_t & l): lp(&l){
    pthread_rwlock_rdlock(lp);
  };
  ~ScopedRDLock(){
    pthread_rwlock_unlock(lp);
  };
  pthread_rwlock_t * lp;
};
class ScopedWRLock {
public:
  ScopedWRLock(pthread_rwlock_t & l): lp(&l){
    pthread_rwlock_wrlock(lp);
  };
  ~ScopedWRLock(){
    pthread_rwlock_unlock(lp);
  };
  pthread_rwlock_t * lp;
};

template <typename T>
class RWSyncronized {
public:
  RWSyncronized(T* t): ptr(t){
    pthread_rwlock_init(&l,NULL);
  };
  ~RWSyncronized(){
    pthread_rwlock_destroy(&l);
    if(ptr != NULL) delete ptr;
  };
  T & i(){
    return *ptr;
  };
  pthread_rwlock_t l;
private:
  RWSyncronized():ptr(NULL){
    pthread_rwlock_init(&l,NULL);
  };
  T * ptr;
};

#define RDSYNCRONIZED(OBJ, STATEMENT) \
  { ScopedRDLock __rd___ ((OBJ)->l); {STATEMENT}; };

#define WRSYNCRONIZED(OBJ, s) \
  { ScopedWRLock __wr___ ((OBJ)->l); {STATEMENT}; };

class SomeClass {
public:
  SomeClass():msg("hello"){};
  void greet() const {
    cout << msg << endl;
  };
  void setmsg(const char* newmsg){
    msg = string(newmsg);
  };
  int i;
  string msg;
};

int main(){
  Syncronized<SomeClass>* s=new Syncronized<SomeClass>(new SomeClass);
  Syncronized<SomeClass>* t=new Syncronized<SomeClass>(new SomeClass);
  SYNCRONIZED(s, {
      s->i().greet();
      SYNCRONIZED(t, {
	  s->i().setmsg("good evening");
	  t->i().greet();
	  s->i().greet();
	});
    });
  delete s;
  delete t;

  RWSyncronized<SomeClass>* p=new RWSyncronized<SomeClass>(new SomeClass);
  RDSYNCRONIZED(p,{
      p->i().greet();
    });
  delete p;
}