c++ memory pool 内存池

这里就直接贴上代码了，基本高效实现。

template<class T>
class MemoryPool {
 public:
  T* Malloc() {
    if (free_element_ == last_element_) {
      return nullptr;
    }
    T* result = reinterpret_cast<T *>(free_element_);
    free_element_ = free_element_->next;
    return result;
  }

  void Free(T* p) {
    if (p == nullptr) {
      return;
    }
    Element* e = reinterpret_cast<Element *>(p);
    e->next = free_element_;
    free_element_ = e;
  }

  void FreeAll() {
    for (int32 i = 0; i < size_-1; i++) {
      all_data_vec_[i]->next = all_data_vec_[i+1];
    }
    all_data_vec_[size_-1]->next = nullptr;
    first_element_ = all_data_vec_[0];
    last_element_ = all_data_vec_[size_-1];
    free_element_ = first_element_->next;
  }

  MemoryPool(int32 num) {
    all_data_vec_.clear();
    size_ = num;
    long ele_len = sizeof(T);
    long buffer_size = ele_len * num;
    // buffer_data_ = (char *)(::operator new(buffer_size));
    // errors in valgrind; new char [] is ok..
    buffer_data_ = new char [buffer_size];
    first_element_ = reinterpret_cast<Element *>(buffer_data_);
    for (long i = 0; i < size_; i++) {
      Element* e = reinterpret_cast<Element *>(buffer_data_ + i*ele_len);
      all_data_vec_.push_back(e);
    }
    FreeAll();
  }

  virtual ~MemoryPool() {
    if (buffer_data_ != nullptr) {
      delete [] buffer_data_;
      first_element_ = nullptr;
      last_element_ = nullptr;
      all_data_vec_.clear();
      buffer_data_ = nullptr;
    }
  }
 
 private:
  union Element {
    union Element* next;
    T* object;
  };

  int32 size_ = 0;
  // for use.
  Element* free_element_ = nullptr;
  Element* used_element_ = nullptr; // ?? not used
  // for record
  Element* first_element_ = nullptr;
  Element* last_element_ = nullptr;

  char* buffer_data_ = nullptr;

  // Element all data, buffer..
  // Element* data_arr_ = nullptr;
  // Element** all_data_ = nullptr;
  std::vector<Element*> all_data_vec_;
};

为了省内存，这里主要用的union来实现的。