C ++ Intel Parallel Studio 2015中的2D动态分配的全局数组

Question

因此，我充分利用了该站点的优势，以获取我认为正确的语法，但是我仍然很困惑。

我在当前使用FFT的项目中引入了一些现有的快速Hartley变换代码，并且所有这些都在工作，除了FHT的大小和重叠是硬编码的，我想使用FFT代码中的值来动态设置运行时的大小。

这需要2D全局数组。

所以我将数组定义为任何函数之外，以便是全局的：

`double         **mInput;`

在init函数中，我这样做：

`

kWindowSize = (int)fftlen; //fftlen is a global from my existing program
mInput = new double*[kWindowSize];
    for (int i = 0; i < kWindowSize; ++i)
        mInput[i] = new double[2];

    printf("\nmInput pointer: %x mInput value: %f", (void *)&mInput, mInput);
    printf("\nfirst sample: %f second sample %f", mInput[0][0], mInput[0][1]);`

但是，可以在另一个函数中编译并正常运行：

`printf("\n\n\n-->mInput pointer: %x mInput value: %f", (void *)&mInput, mInput);
    printf("\n-->first sample: %f second sample %f", mInput[0][0]);
    printf("\n-->second sample %f", mInput[0][1]);`

它在第二个printf状态崩溃（试图访问2d数组中的值），并且非法写入位置零。

似乎for循环内的new语句正在创建局部数组，而不是全局数组？

由于我从这里获得了动态分配语法，因此我开始怀疑这是否是intel编译器中的错误？

有什么建议吗？

谢谢！

Answer 1

我已经了解了全局2D数组或双指针的想法，并且这样做可能会对您有所帮助，而无需使用vector ， list ， array但是将其包装到使用智能指针的模板类结构中。 我做了这样的事情：

#include <memory>
template <typename T = double>
struct Buffer {
    T* ptdatafield_ { nullptr };
    T* ptdata_ { nullptr };
    Buffer();
};

template<>
Buffer<double>::Buffer() {};

template<typename T = double>
class FFTBuffer {
public: 
    std::unique_ptr< Buffer<T> > unique_ptr_buffer_ { nullptr };

    union {
        T** pprawbuffer_ { nullptr };                       

        struct {
            std::shared_ptr<T> sub_shared_BufferIndexi_;
            std::shared_ptr<T> sub_shared_BufferIndexj_;
        };

        struct {
            T* rawIndexi_;
            T* rawIndexj_;
        };
    };

    explicit FFTBuffer( const Buffer<T>& buffer );      
    ~FFTBuffer() {};
};

template<>
FFTBuffer<double>::FFTBuffer( const Buffer<double>& buffer ) :
unique_ptr_buffer_( std::make_unique<Buffer<>>( buffer ) ), 
rawIndexi_( buffer.ptdatafield_ ), rawIndexj_( buffer.ptdata_ ) {    
}

int main() {
    Buffer<> buffer;
    FFTBuffer<> fftBuffer( buffer );

    Buffer<>* pBuffer = new Buffer<>();
    FFTBuffer<> fftBuffer2( *pBuffer );

    return 0;
}

现在，此代码按原样编译，但我尚未使用值或填充内部数组对其进行测试。 我添加了带有无名结构的公共工会的使用。 如果对齐正确，则应与2D数组（例如MxN矩阵）中的行和列匹配。 此类将unique_ptr<>存储到Buffer对象，该对象本身具有两个单独的指针，每个指针用于数组的每个维度。 然后，它使用该Buffer对象在其内部的无名结构和双指针的公共联合中设置数据字段。 这是访问相同内存位置的多种方法。

这个想法通常是建立这种联系。

//.....

int i, j;
(fftBuffer.unique_ptr_buffer_.get()->ptdatafield_[i], fftBuffer.unique_ptr_buffer_.get()->ptdata_[j]) =  
fftBuffer.pprawbuffer_[i][j] = 
(fftBuffer.rawIndexi_[i], fftBuffer.rawIndexj_[j] =
(fftBuffer.sub_shared_BufferIndexi_.get()[i], fftBuffer.sub_shared_BufferIndexj_.get()[j]) 

现在，我没有实现或不包含[]重载运算符或任何其他运算符，但是它们应该不那么难实现。 这将在视觉上帮助您了解如何将2D数组线性存储在内存中，以及无需“ double for循环”即可访问或分配元素。

除了任何和所有反馈外，对于您对此算法的伪代码的设计意图以及简短的决策解释，我将不胜感激。 我想听听为什么这是“好还是不好”的代码的利弊，可以在其设计和实现上加以改进，以及它可能带来什么其他复杂性。

-就我个人而言，除非它们是永远不变的const值或静态全局变量（例如，指向单例类对象的静态全局指针），否则我会尽量避免使用它们。 -