Effective C++: C++11模板元编程.

我们先来看一个例子吧:

#include <iostream>
#include <memory>
#include <utility>

template<typename T>
std::ostream& print(std::ostream& os, const T& t)
{
 os<<t;
 return os;
}

template<typename T, typename... args>
std::ostream& print(std::ostream& os, const T& t, const args&... package)
{
 os<<t<<"  "<<"package Size: "<<sizeof...(package)<<" ";
 return print(os, package...);
}

template<typename T>
class StrVec{
 private:
  std::allocator<T> alloc_;
  T* data_ptr_;
  T* ptr_;
  int numbers_;
  
  public:
   StrVec(const int& n_);
   
   ~StrVec();
  
  T& operator[](const int& index_);
  
  template<typename... args>
  void constructor(T* p, const T& t, args&&... package);
  
  void constructor(T* p, const T& t);
  
  inline T* get_ptr()noexcept
  {
   return this->ptr_;
  }
  
  void print()const;
};

template<typename T>
StrVec<T>::StrVec(const int& n_)
          :data_ptr_(nullptr),
           ptr_(nullptr),
           numbers_(n_)
{
 this->data_ptr_ = alloc_.allocate(this->numbers_);
 this->ptr_ = this->data_ptr_;
}

template<typename T>
template<typename... args>
void StrVec<T>::constructor(T* p, const T& t, args&&... package)
{
 this->alloc_.construct(p++, t);
 this->constructor(p++, std::forward<args>(package)...);
}

template<typename T>
void StrVec<T>::constructor(T* p, const T& t)
{
 std::cout<<"----"<<std::endl;
 (this->alloc_).construct(p, t);
}

template<typename T>
StrVec<T>::~StrVec()
{
 while(this->data_ptr_ != nullptr){
  this->alloc_.destroy((this->data_ptr_)--);
 }
}

template<typename T>
T& StrVec<T>::operator[](const int& index)
{
 return *(this->ptr_ + index);
}

int main()
{
 print(std::cout, 1, std::string("shihuawoaini"), 9.0, "shihuawoaini");
 int x = 20;
 
 std::allocator<int> a;
 const int* ptr = a.address(10);
 
 int* ptr_two = a.address(x);
 *ptr_two = 30;
 std::cout<<x<<std::endl;
 
 StrVec<int> vec(5);
 int* ptr_three = vec.get_ptr();
 
 vec.constructor(ptr_three, 1, 2, 4, 5);  
 std::cout<<vec[3]<<std::endl;
 
 return 0;
}