编辑代码

#include <iostream>
#include <string>
#include <memory>
#include <queue>


using namespace std;
using SkuId = int64_t;

namespace entity {
struct AdSkuInfo {

};
}
template<typename CacheValueType>
class ExpiredLruGcPtrValue {
public:
  ExpiredLruGcPtrValue()
    : cache_time_(0)
    , pvalue_(NULL)
    , is_upgrade_(false)
  {}

  void InitValue() {
      if (pvalue_ == nullptr) {
          pvalue_ = new CacheValueType();
      }
  }

public:
  bool is_upgrade_;
  int64_t cache_time_;
  CacheValueType* pvalue_;
};
/** LRU cache*/
template<typename KeyType, typename ValueType>
class ExpiredLruGcCache {
    public:
        ExpiredLruGcCache() {
            cout  << "ExpiredLruGcCache: key, value" << endl;
        }
        void Init() {
            int nCount = 10;
            ExpiredLruGcPtrValue<ValueType> * value = new ExpiredLruGcPtrValue<ValueType>[nCount];
            if (value) {
                for (size_t i = 0; i < nCount; ++i) {
                    value[i].InitValue();
                    free_node_.push(value + i);
                }
            }
        }
        void Print() {
            cout << "This is  Base ExpiredLruGcCache" << endl;
        }
        void GetEmptyAdSkuInfo(ValueType** value) {
            ExpiredLruGcPtrValue<ValueType>* gc_value;
            gc_value = free_node_.front();
            free_node_.pop();
            if (gc_value == nullptr) {
                return;
            }
            *value = gc_value->pvalue_;
            if (*value == nullptr) {
                *value = new ValueType();
                cout << "======  extra_new"  << endl;
            }
        }
    
    public:
        std::queue<ExpiredLruGcPtrValue<ValueType>*> free_node_;
};

/*template<>
class ExpiredLruGcCache<int64_t, entity::AdSkuInfo> {
    public:
        ExpiredLruGcCache() {
            cout  << "ExpiredLruGcCache: SkuId, sting" << endl;
        }
        void Print() {
            cout << "This is  Spical  ExpiredLruGcCache" << endl;
        }
};*/

/* GlobalGcCacheImpl */
template <typename KeyType, typename ValueType>
class GlobalGcCacheImpl {
    public:
        GlobalGcCacheImpl() {}
        virtual void Print() = 0;
};

template <typename KeyType, typename ValueType>
class LRUGcCacheImpl : public GlobalGcCacheImpl<KeyType, ValueType> {
        std::unique_ptr<ExpiredLruGcCache<KeyType, ValueType>> cache_;
    public:
        LRUGcCacheImpl() {
            cache_.reset(new ExpiredLruGcCache<KeyType, ValueType>());
        }
        void Print() override {
            cache_->Print();
        }
};

template <typename KeyType, typename ValueType>
class GlobalGcCache {
    public:
        GlobalGcCache() {
            impl_.reset(new LRUGcCacheImpl<KeyType, ValueType>());
        }
        void Print() {
            impl_->Print();
        }
    protected:
        std::unique_ptr<GlobalGcCacheImpl<KeyType, ValueType>> impl_;
};

/*SkuContext*/
template <typename KeyType, typename ValueType>
struct SkuContextTypeParallel {
    SkuContextTypeParallel() {
    }
    void Print() {
        global_cache_->Print();
    }

    std::shared_ptr<GlobalGcCache<KeyType, ValueType>> global_cache_;
};

struct SkuDaoContext {
    virtual void Print() = 0;
};

struct SkuDaoContextParallel : public SkuDaoContext {
    public:
        SkuDaoContextParallel() {
            sku_context_.reset(new SkuContextTypeParallel<SkuId, entity::AdSkuInfo>);
        }
        void Print() override {
            sku_context_->Print();
        }
        
        std::unique_ptr<SkuContextTypeParallel<SkuId, entity::AdSkuInfo>> sku_context_;
};

/*SkuDaoCreator*/
class SkuDaoCreator {
    public:
        static SkuDaoCreator &Instance();
        std::shared_ptr<SkuDaoContext> NewDaoContext() {
            auto dao_context = std::make_shared<SkuDaoContextParallel>();
            global_sku_cache_.reset(
                new GlobalGcCache<SkuId, entity::AdSkuInfo>());
            dao_context->sku_context_->global_cache_ = global_sku_cache_;
            return dao_context;
        }
        void Print() {
            global_sku_cache_->Print();
        }
    private:
        std::shared_ptr<GlobalGcCache<SkuId, entity::AdSkuInfo>> global_sku_cache_;
};
SkuDaoCreator &SkuDaoCreator::Instance() {
  static SkuDaoCreator ins;
  return ins;
}

/*SkuDao*/
class SkuDao {
public:
    SkuDao() {
        dao_context_ = SkuDaoCreator::Instance().NewDaoContext();        
    }
    void Print() {
        dao_context_->Print();
    }
private:
    std::shared_ptr<SkuDaoContext> dao_context_;
};

int main() {
	cout << "Hello world!    - cpp.jsrun.net." << endl << endl;
    /*SkuDao sku_dao;
    sku_dao.Print();*/
    
	return 0;
}