C++ C+中的2D动态分配全局数组+；英特尔并行工作室2015

因此，我使用这个网站，以良好的优势，以获得什么，我相信是正确的语法为这一点，但我仍然卡住了

我在我的项目中引入了一些预先存在的快速hartley变换代码，目前使用FFT，除了FHT的大小和重叠外，所有这些都是硬编码的，我想使用FFT代码中的值在运行时动态设置大小

---

这需要二维全局数组

因此，我在任何函数之外定义数组，以便全局：

`double         **mInput;`

在init函数中，我执行以下操作：

`

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

似乎for循环中的新语句正在创建一个局部数组，而不是全局数组

因为我从这里得到了动态分配语法，我开始怀疑这是否是英特尔编译器中的一个bug

建议

---

谢谢

我接受了您关于全局2D数组或双指针的想法，我这样做可能会对您有所帮助，而无需使用

向量

，

列表

，

数组

，但将其包装到使用智能指针的模板类结构中。我做过这样的事情：

#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数组是如何在内存中线性存储的，并在不需要“双for循环”的情况下访问或分配元素

我将非常感谢，除了任何和所有关于这个算法的伪代码设计意图的反馈，并对您的决定进行简短的描述性解释。我很想听听正反两方面的意见，为什么这是一个“好的或坏的”代码，在设计和实现方面可以改进，以及这可能会带来什么其他复杂性

---

--就我个人而言，我尽量避免使用独立全局变量，除非它们是永不改变的常量值，或者是静态全局变量，例如指向单例类对象的静态全局指针--

我接受了您关于全局2D数组或双指针的想法，我这样做可能会对您有所帮助，而无需使用

向量

，

列表

，

数组

，但将其包装到使用智能指针的模板类结构中。我做过这样的事情：

#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数组是如何在内存中线性存储的，并在不需要“双for循环”的情况下访问或分配元素

我将非常感谢，除了任何和所有关于这个算法的伪代码设计意图的反馈，并对您的决定进行简短的描述性解释。我很想听听正反两方面的意见，为什么这是一个“好的或坏的”代码，在设计和实现方面可以改进，以及这可能会带来什么其他复杂性

---

--就我个人而言，我尽量避免使用独立全局变量，除非它们是永不改变的常量值，或者是静态全局变量，例如指向单例类对象的静态全局指针--

您没有在

double**

上使用

std:：vector

的任何原因？当

printf

需要

%f

时，传递

mInput

是不好的<代码>printf（“\n-->第一个样本：%f第二个样本%f”，mInput[0][0]）在本例中，

printf

需要两个参数。“这需要2D全局数组”-谁说的？如果你想要的话，总是可以避免使用全局变量。

newdouble[2]

？真的吗？printf只是用来调试的。第一次在init函数外部写入mInput时，代码崩溃。您没有在

double**

上使用

std:：vector

的任何原因？当

printf

需要

%f

时，传递

mInput

是不好的<代码>printf（“\n-->第一个样本：%f第二个样本%f”，mInput[0][0]）在本例中，

printf

需要两个参数。“这需要2D全局数组”-谁说的？如果你想要的话，总是可以避免使用全局变量。

newdouble[2]

？真的吗？printf只是用来调试的。第一次在init函数外部写入mInput时，代码崩溃。

#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;
}

//.....

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])