当C++遇到IOS应用开发---LRUCache缓存

       考虑到缓存实现多数使用单例模式，这里使用C++的模版方式设计了一个Singlton基类，这样以后只要继承该类，子类就会支持单例模式了。其代码如下：
 
[cpp] 
// 
//  SingltonT.h 
// 
 
#ifndef SingltonT_h 
#define SingltonT_h 
#include <iostream> 
#include <tr1/memory> 
using namespace std; 
using namespace std::tr1; 
template <typename T> 
class Singlton { 
public: 
      static T* instance(); 
      ~Singlton() { 
          cout << "destruct singlton" << endl; 
      } 
protected: 
      Singlton(); 
//private: 
protected: 
      static std::tr1::shared_ptr<T> s_instance; 
      //Singlton(); 
}; 
 
template <typename T> 
std::tr1::shared_ptr<T> Singlton<T>::s_instance; 
  
template <typename T> 
Singlton<T>::Singlton() { 
    cout << "construct singlton" << endl; 
} 
  
template <typename T> 
T* Singlton<T>::instance() { 
    if (!s_instance.get()) 
        s_instance.reset(new T); 
    return s_instance.get(); 
} 

       另外考虑到在多线程下对static单例对象进行操作，会出现并发访问同步的问题，所以这里使用了读写互斥锁来进行set（设置数据）的同步。如下：
[cpp] 
#ifndef _RWLOCK_H_ 
#define _RWLOCK_H_ 
 
#define LOCK(q) while (__sync_lock_test_and_set(&(q)->lock,1)) {} 
#define UNLOCK(q) __sync_lock_release(&(q)->lock); 
 
struct rwlock { 
    int write; 
    int read; 
}; 
 
static inline void 
rwlock_init(struct rwlock *lock) { 
    lock->write = 0; 
    lock->read = 0; 
} 
 
static inline void 
rwlock_rlock(struct rwlock *lock) { 
    for (;;) {//不断循环，直到对读计数器累加成功 
        while(lock->write) { 
            __sync_synchronize(); 
        } 
        __sync_add_and_fetch(&lock->read,1);