1

在性能方面，有没有更好的方法来做到这一点？

例如，创建一个名为 arraydata 的类/结构，它会分配一些对齐的内存供使用（尽管 .dataPtr 提供了一个指针）：

class arraydata//to allocate some memory, 
               //and return a pointer to that block of memory
{
    void *dataPtrV;

  public:

    double *dataPtr;

    arraydata(int a, int b)
    {
        dataPtrV=_aligned_malloc(a*b*sizeof(double),32);
        dataPtr=(double *)dataPtrV;
    }

    ~arraydata()
    {
        _aligned_free(dataPtrV);
        dataPtrV=NULL;
        dataPtr=NULL;
    }   
};

然后通过以下方式调用它：

     arraydata X(30,20);
4

1 回答 1

6

是的，这将被视为 RAII - 资源在构造函数中获取并在析构函数中释放。

我不确定你为什么要同时存储 avoid*和 adouble*虽然 - 只有 adouble*就足够了。

另外，在复制你的类时要非常小心，因为这很容易导致泄漏并释放已经释放的数据。

无论如何，这也可以使用std::unique_ptr更惯用的方式来完成，并且不会影响您的班级：

struct aligned_free {
  void operator()(void* p) {
     _aligned_free(p);
  }
};

template<typename T>
T* aligned_malloc(std::size_t size, std::size_t alignment) {
  return static_cast<T*>(_aligned_malloc(size * sizeof(T), alignment));
}

std::unique_ptr<double, aligned_free> make_array_data(int a, int b) {
    return std::unique_ptr<double, aligned_free>(aligned_malloc<double>(a*b, 32));
}

auto arraydata = make_array_data(30, 20);

这是您的课程，没有void*：

class arraydata//to allocate some memory, 
               //and return a pointer to that block of memory
{

  public:

    double *dataPtr;

    arraydata(int a, int b)
    {
        dataPtr=static_cast<double*>(_aligned_malloc(a*b*sizeof(double),32));
    }

    ~arraydata()
    {
        _aligned_free(dataPtr);
    }   
};
于 2012-11-03T10:16:56.360 回答