Question

我经常使用多维数组，而且我不是friend CLS operator+(CLS lhs, const CLS& rhs) { // Do your logic here return lhs; }的忠实粉丝，因为无法实例化std::vector或std::vector {{1}使用引用而不复制基础数据。

对于一维数组，我使用以下

std::vector

这非常方便，允许我实例化一个动态大小的数组，该数组的大小也为零。此外，我可以使用std::vector传递数据而无需复制。

对于二维数组，我想做类似

的事情

template<typename T>
using deleted_aligned_array = std::unique_ptr<T[], std::function<void(T*)> >;

template<typename T>
deleted_aligned_array<T> deleted_aligned_array_create(size_t n) {
  return deleted_aligned_array<T>((T*)_mm_malloc(n*sizeof(T),16), [](T* f)->void { _mm_free(f);});
}

适用于零大小的数组，但由于显而易见的原因std::forward，我从template<typename T> using deleted_aligned_array2 = std::unique_ptr<T*,std::function<void(T**)>>; template<typename T> deleted_aligned_array2<T> deleted_aligned_array_create(size_t m, size_t n) { auto arr = deleted_aligned_array2(new T*[m](), [&](T** x) { if (malloc_usable_size(x) > 0) { _mm_free(&(x[0][0])); } delete[] x;}); if (m*n > 0) { arr.get()[0] = (T*) _mm_malloc(m*n*sizeof(T),16); // Row pointers for (size_t iRow = 1; iRow < m; iRow++) { (m_data.get())[iRow] = &(m_data.get()[0][iRow*n]); } } return arr; }收到错误。

是否有可能以优雅的方式解决这个问题，而不创建一个保持valgrind成员的整个类，我在其中实现移动构造函数，移动赋值等。最后，我想将此概括为用于任何维度

invalid read of size 8

返回的数组应该是一个唯一的指针，递归初始化行指针，它应该支持零大小的数组，例如

std::unique_ptr

应返回带有行和列指针的三维数组。

问题： 1）避免以简单的方式读取无效数据。 2）使用模板参数template<typename T, size_t Dim> deleted_aligned_array<T,D> deleted_aligned_array_create(...);生成类型：auto arr = deleted_aligned_array_create<float,3>(4,5,10);，D并简单地将T*传递给递归生成行指针的代码（我已经拥有）。 3）最好以便携方式。 T**是GNU扩展，在D上调用它会导致读取无效，大小为0时。

提前致谢

Answer 1

我找到了一个解决方案，但它不是很优雅。如果您有更优雅的解决方案，请发布您的答案。一旦我们达到更高的维度，这里的解决方案非常难看。

template <class T, size_t D>
class deleted_aligned_multi_array {
};

template <class T>
class deleted_aligned_multi_array<T,1> : public std::unique_ptr<T[], std::function<void(T*)> > {
  deleted_aligned_multi_array(size_t n) :
    std::unique_ptr<T[], std::function<void(T*)> >((T*)_mm_malloc(n*sizeof(T),16),
                                                   [](T* f)->void { _mm_free(f);}) {}
};

template <class T>
class deleted_aligned_multi_array<T,2> {
public:
  typedef T** pointer;
  typedef std::unique_ptr<T*, std::function<void(T**)>> deleted_unique_array;

  deleted_aligned_multi_array() : m(0), n(0), data() {}

  deleted_aligned_multi_array(size_t m, size_t n) : m(m), n(n) {
    if (m*n > 0) {
      data = deleted_unique_array(new T*[m](),
                                    [&](T** x) {
                                      if (sps::msize(x) > 0) {
                                        _mm_free(&(x[0][0]));
                                      }
                                      delete[] x;});

      data.get()[0] = (T*) _mm_malloc(m*n*sizeof(T),16);

      for (size_t iRow = 1; iRow < m; iRow++) {
        (data.get())[iRow] = &(data.get()[0][iRow*n]);
      }
    }
    else {
      data.reset();
    }
  }

  deleted_aligned_multi_array(deleted_aligned_multi_array&& other) : m(other.m), n(other.n),
                                 data(std::move(other.data)) {}

  deleted_aligned_multi_array& operator=( deleted_aligned_multi_array&& other ) {
    if (this != &other) {
      data = std::move( other.data );
      m    = other.m;
      m    = other.n;
    }
    return *this;
  }

  T& operator()(size_t i, size_t j) {
    return this->data.get()[0][i*n + j];
  }

  T* operator[](size_t m) {
    return &(data.get()[m][0]);
  }

  const T* operator[](size_t m) const {
    return data.get()[m];
  }

  pointer get() const {
    return data.get();
  }

  void reset(pointer __p = pointer()) {
    data.reset(__p);
  }

  template<typename _Up>
  void reset(_Up) = delete;

private:
  deleted_aligned_multi_array(const deleted_aligned_multi_array& other) = delete;
  deleted_aligned_multi_array& operator=( const deleted_aligned_multi_array& a ) = delete;

public:
  size_t m;                   ///<Number of rows
  size_t n;                   ///<Number of columns
  deleted_unique_array data;  ///<Data
};

现在可以轻松地创建用于访问子数组的实用程序功能

template <class T>
std::unique_ptr<T*, std::function<void(T*)> sub_array(size_t m, size_t n, size_t i, size_t j) {
  // Establish row pointers with reference i and j and dimension mxn.
}

unique_ptr的零大小

1 个答案: