实现生成器,语法更简洁:

shape是一个全局唯一对象,用来生成多维数组的'外观',可以拿传统的C语法进行比较:

定义一个三维数组(传统):

int a[3][4][5];

一个动态三维数组:

auto_array<int,3> a(shape[3][4][5]);

形式上很相似,如果你不进行特殊的操作,完全可以拿下面的a代替上面的.所不同的是,传统的[3][4][5]是需要在编译期确定的,而下面的可以是运行期的动态变量,所在的存储空间也不同,上面占用栈空间,下面的是在堆上,由指定的分配器优化分配的.

你如果随意乱用shape,比如

auto_array<int,3> a(shape[3][4]);

将会引发编译错误,同样的,对其它维度数和shape后面的[]数不同的形式都会报错.换句话说,shape的[]会返回不同的类型,这取决于你用了几次[].

shape还可以用来传给reshape,形式是

a.reshape(shape[3][4][5]);

它不能再继续加括号指定范围了,他不能指定起始下标,如果希望不从0开始下标数组,只能使用另一种形式的reshape,这种形式值得再说明一下.

reshape(dim0,width0,start0)(dim1,width1,start1)(...)...;

为了防止空间的重复无用的分配,这里的reshape,在调用operator()的时候,并没有真的去'分配'它,只是设定了相应的维度宽度等值.而需要真正分配空间,可以几种方法:

1,调用一次operator[],哪怕没任何用.

2,在reshape语句末尾,加上一句now(),如

a.reshape(0,4)(1,5).now();

则会马上发生分配.有没有真的分配,会影响到其它和容器相关的函数,包括:

safe_bool转型,可以这样使用:

if(a)
  cout<<"a is not empty!"<<endl;

a可以自动转型,但这是安全的,你不能指望这样的代码通过编译:

bool b=a;

或者其它形式的头疼地隐式转换:

a && true;

[这种安全转型是从boost里学的;)]

此外还有一些标准的迭代器函数,begin(),end()等,另外还有一个operator&,用来返回数组的首地址,这和C语言兼容:

int *add=&a;

但是,推荐少用,因为&a会发生改变,因此add不能存起来过后使用.

最后,数组不能直接拷贝,但是可以拷贝构造.当然你可以使用算法copy,那是面向迭代器,而迭代器的引用只要元素能拷贝就能完成任务,阻止拷贝的目的是,防止一个书写不当,引起整体的费时地拷贝.

[其它可能还有一些想法,再陆续加进来]

最新代码:

#ifndef AUTO_ARRAY
#define AUTO_ARRAY

#include <stdexcept>

//test allocator
template<typename T>
class _test_allocator
{
public:
  static void* allocate(std::size_t n)
  {
    return malloc(n*sizeof(T));
  }

  static void deallocate(void* p, std::size_t /* __n */)
  {
    free(p);
  }

  static void* reallocate(void* __p, std::size_t /* old_sz */, std::size_t __new_sz)
  {
    return realloc(__p, __new_sz*sizeof(T));
  }
};

//implemention of auto_array internal

struct range_list
{
  long start;
  std::size_t width;
  std::size_t step;
};

template<typename T, std::size_t dim, typename Allocator = _test_allocator<T> >
struct auto_array_impl
{
  auto_array_impl() : range_changed(false), data(0), length(0), max_sz(0) {}
  auto_array_impl(const auto_array_impl& r) : range_changed(r.range_changed), data(0), length(r.length), max_sz(r.max_sz)
  {
    // deep copy
    if(r.empty())
      return;
    data=allocate(r.max_sz);
    for(std::size_t i=0;i<r.max_sz;++i)
      data[i]=r.data[i];
    for(std::size_t i=0;i<dim;++i)
      rl[i]=r.rl[i];
  }
  virtual ~auto_array_impl()
  {
    clear();
  }
 
  T* allocate(std::size_t n)
  {
    return static_cast<T*>(Allocator::allocate(n));
  }
  void deallocate(T* p, std::size_t sz)
  {
    Allocator::deallocate(static_cast<void*>(p),sz);
  }
  T* reallocate(T* p, std::size_t _old_sz, std::size_t _new_sz)
  {
    return static_cast<T*>(
      Allocator::reallocate(static_cast<void*>(p),_old_sz,_new_sz)
      );
  }
  bool getready();
  void clear();

  range_list rl[dim];
  bool range_changed;
  T* data;
  std::size_t length;
  std::size_t max_sz;
};

template<typename T, std::size_t dim, typename Allocator>
bool auto_array_impl<T,dim,Allocator>::getready()
{
  if(range_changed)
  {
    std::size_t _new_length=1;
    for(long i=dim-1;i>=0;--i)
    {
      _new_length*=rl[i].width;
      rl[i].step = (i+1==dim?1:rl[i+1].step*rl[i+1].width);
    }
    if(_new_length>max_sz)
    {
      do{
        max_sz = (max_sz==0?128:(max_sz<<1));
      }while(_new_length>max_sz);
      if(data)
        data=reallocate(data,0,max_sz);
      else
        data=allocate(max_sz);
    }
    length=_new_length;
    range_changed=false;
  }
  return length>0;
}

template<typename T, std::size_t dim, typename Allocator>
void auto_array_impl<T,dim,Allocator>::clear()
{
  if(data)
  {
    deallocate(data,max_sz);
    data=0;
    max_sz=0;
  }
}

//generator of auto_array ; use global object 'shape'
template<std::size_t dim>
class auto_array_gen
{
public:
  auto_array_gen(const auto_array_gen<dim-1>& pre, std::size_t width) : pre_gen(pre), cur_width(width) {}
  auto_array_gen<dim+1>
  operator[](std::size_t width) const
  {
    return auto_array_gen<dim+1>(*this,width);
  }
  void set_range(range_list* rl) const
  {
       rl[dim-1].start=0;
       rl[dim-1].width=cur_width;
       pre_gen.set_range(rl);
  }
private:
  auto_array_gen<dim-1> pre_gen;
  std::size_t cur_width;
};

template<>
class auto_array_gen<1>
{
public:
  explicit auto_array_gen(std::size_t width) : cur_width(width) {}
  auto_array_gen<2>
  operator[](std::size_t width) const
  {
    return auto_array_gen<2>(*this,width);
  }
  void set_range(range_list* rl) const
  {
       rl[0].start=0;
       rl[0].width=cur_width;
  }
private:
  std::size_t cur_width;
};

template<>
class auto_array_gen<0>
{
public:
  auto_array_gen<1>
  operator[](std::size_t width) const
  {
    return auto_array_gen<1>(/* *this, */width); // *this cannot be copy-constructed
  }
  static auto_array_gen* Instance()
  {
    if(0==instance)
    {
        instance = new auto_array_gen;
    }
    return instance;
  }
private:
  auto_array_gen() {}
  auto_array_gen(auto_array_gen&) {}
  static auto_array_gen *instance;
};

auto_array_gen<0>* auto_array_gen<0>::instance = 0;

auto_array_gen<0>& shape=*auto_array_gen<0>::Instance();

//auto_array interfaces
template<typename T, std::size_t dim, typename Allocator = _test_allocator<T> >
class auto_array
{
public:
  typedef T value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type* iterator;
  typedef const value_type* const_iterator;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef std::size_t size_type;
  typedef ptrdiff_t difference_type;
 
  virtual ~auto_array()
  {
          delete ptimpl;
  }
 
  auto_array()
  {
    ptimpl=new auto_array_impl<T,dim,Allocator>;
    for(std::size_t i=0;i<dim;++i)
      ptimpl->rl[i].width=0;
  }
 
  auto_array(const auto_array& r)
  {
    ptimpl=new auto_array_impl<T,dim,Allocator>(*r.ptimpl);
  }
 
  explicit auto_array(const auto_array_gen<dim>& gen)
  {
    ptimpl=new auto_array_impl<T,dim,Allocator>;
    ptimpl->range_changed=true;
    gen.set_range(ptimpl->rl);
    ptimpl->getready();
  }
 
  template<typename _T, std::size_t _dim, typename _Allocator>
  class reshape_functor
  {
  public:
    reshape_functor(auto_array_impl<_T,_dim,_Allocator>* _ptimpl) : ptimpl(_ptimpl) {}
    reshape_functor operator()(std::size_t dim_index, std::size_t width, long start = 0)
    {
      if(dim_index>=_dim)
        throw(std::runtime_error("array reshape error: dimensionality too big"));
      ptimpl->rl[dim_index].start=start;
      ptimpl->rl[dim_index].width=width;
      return *this;
    }
    bool now() { return ptimpl->getready(); }
  private:
    auto_array_impl<_T,_dim,_Allocator>* ptimpl;
  };
 
  reshape_functor<T,dim,Allocator>
  reshape(std::size_t dim_index, std::size_t width, long start = 0)
  {
    ptimpl->range_changed=true;
    return reshape_functor<T,dim,Allocator>(ptimpl)(dim_index,width,start);
  }
 
  void
  reshape(const auto_array_gen<dim>& gen)
  {
    ptimpl->range_changed=true;
    gen.set_range(ptimpl->rl);
    ptimpl->getready();
  }

  template<typename _T, std::size_t _dim>
  class index_functor
  {
  public:
    index_functor(_T *pdata, const range_list *prl) : data(pdata), rl(prl) {}
    index_functor<_T,_dim-1> operator[](long index)
    {
      if(index>=rl[0].start && index-rl[0].start<static_cast<long>(rl[0].width))
        return index_functor<_T,_dim-1>(data+(index-rl[0].start)*rl[0].step,rl+1);
      else
        throw(std::runtime_error("array access error: out of bound"));
    }
  private:
    _T *data;
    const range_list *rl;
  };
 
  template<typename _T>
  class index_functor<_T,0>
  {
  public:
    index_functor(_T *pdata, const range_list *prl) : data(pdata) {}
    operator _T(){ return data[0]; }
   
    template<typename U>
    _T& operator=(const U &other){ return data[0]=other; }
   
    template<typename U>
    _T& operator+=(const U &other){ return data[0]+=other; }
   
    template<typename U>
    _T& operator-=(const U &other){ return data[0]-=other; }
   
    template<typename U>
    _T& operator*=(const U &other){ return data[0]*=other; }
   
    template<typename U>
    _T& operator/=(const U &other){ return data[0]/=other; }
   
    template<typename U>
    _T& operator%=(const U &other){ return data[0]%=other; }
   
    template<typename U>
    _T& operator<<=(const U &other){ return data[0]<<=other; }
   
    template<typename U>
    _T& operator>>=(const U &other){ return data[0]>>=other; }
   
    template<typename U>
    _T& operator^=(const U &other){ return data[0]^=other; }
   
    template<typename U>
    _T& operator&=(const U &other){ return data[0]&=other; }
   
    template<typename U>
    _T& operator|=(const U &other){ return data[0]|=other; }
   
  private:
    _T *data;
  };
 
  index_functor<T,dim-1>
  operator[](long index)
  {
    if(ptimpl->getready())
      return index_functor<T,dim>(ptimpl->data,ptimpl->rl)[index];
    else
      throw(std::runtime_error("array access error: shape uninitialized"));
  }
 
  struct dummy{void nonnull(void){}};
  typedef void (dummy::*safe_bool)(void);
  operator safe_bool() {return ptimpl->data==0?0:&dummy::nonnull;}
 
  bool empty() const {return ptimpl->data==0;}
 
  size_type size() const { return ptimpl->length; }
 
  size_type max_size() const { return ptimpl->max_sz; }
 
  void clear()
  {
    ptimpl->clear();
  }
 
  void operator=(int zero){ ptimpl->clear(); }
 
  iterator begin() { return ptimpl->data; }
  const_iterator begin() const { return ptimpl->data; }
 
  iterator end() { return ptimpl->data+ptimpl->length; }
  const_iterator end() const { return ptimpl->data+ptimpl->length; }
 
  void swap(auto_array& r)
  {
    using std::swap;
    swap(ptimpl,r.ptimpl);
  }
 
  iterator operator&() { return begin(); }
 
private:
  void operator=(const auto_array<T,dim,Allocator>&);
  auto_array_impl<T,dim,Allocator>* ptimpl;
};

#endif

rickone 2008/02/19

评论