如何避免动态分配内存 C++

Question

[编辑] 在这个 get 方法之外（见下文），我想要一个指针 double * result; 然后调用 get 方法，即

    // Pull results out
    int story = 3;
double * data;
int len;
m_Scene->GetSectionStoryGrid_m(story, data, len);

话虽如此，我想要一个 get 方法，它通过引用简单地设置结果 (*&data)，而不是动态分配内存。

我正在寻找的结果已经存在于内存中，但它们在 C 结构中并且不在一个连续的内存块中。仅供参考，&len 只是数组的长度。我想要一个包含所有结果的大数组。

由于我要查找的实际结果存储在本机 C 结构指针 story_ptr->int_hv[i].ab.center.x; 中。我将如何避免像上面那样动态分配内存？我想将数据*指向结果，但我只是不知道该怎么做。可能是我忽略了一些简单的东西……代码如下。

这甚至可能吗？根据我的阅读，它不是，但正如我的用户名所暗示的那样，我不是软件开发人员。感谢所有到目前为止回复的人！

这是一段sn-p代码：

void GetSectionStoryGrid_m( int story_number, double *&data, int &len )
{

    std::stringstream LogMessage;

    if (!ValidateStoryNumber(story_number))
    { 
            data = NULL;
            len = -1;
    }
    else
    {
            // Check to see if we already retrieved this result
            if ( m_dStoryNum_To_GridMap_m.find(story_number) == m_dStoryNum_To_GridMap_m.end() )
            {
                    data   = new double[GetSectionNumInternalHazardVolumes()*3];
                    len = GetSectionNumInternalHazardVolumes()*3;

                    Story * story_ptr = m_StoriesInSection.at(story_number-1);
                    int counter = 0;  // counts the current int hv number we are on

                    for ( int i = 0; i < GetSectionNumInternalHazardVolumes() && story_ptr->int_hv != NULL; i++ )  
                    {  
                            data[0 + counter] = story_ptr->int_hv[i].ab.center.x;
                            data[1 + counter] = story_ptr->int_hv[i].ab.center.y;
                            data[2 + counter] = story_ptr->int_hv[i].ab.center.z;

                            m_dStoryNum_To_GridMap_m.insert( std::pair<int, double*>(story_number,data));

                            counter += 3;
                    }
            }
            else
            {
                    data = m_dStoryNum_To_GridMap_m.find(story_number)->second;
                    len = GetSectionNumInternalHazardVolumes()*3;
            }
    }
}

Answer 1

考虑返回一个自定义访问器类而不是“double *&data”。根据您的需要，该类将如下所示：

class StoryGrid {
    public:
        StoryGrid(int story_index):m_storyIndex(story_index) {
            m_storyPtr =  m_StoriesInSection.at(story_index-1);
        }
        inline int length() { return GetSectionNumInternalHazardVolumes()*3; }

        double &operator[](int index) {
            int i = index / 3;
            int axis = index % 3;
            switch(axis){
                case 0: return m_storyPtr->int_hv[i].ab.center.x;
                case 1: return m_storyPtr->int_hv[i].ab.center.y;
                case 2: return m_storyPtr->int_hv[i].ab.center.z;
            }
        } 
};

抱歉有任何语法问题，但你明白了。返回对此的引用并将其记录在您的地图中。如果正确完成映射，则管理所需的所有动态分配。

Answer 2

因此，您希望分配的数组在调用堆栈中“向下”。您只能使用动态分配在堆中分配它。或者创建一个static 变量，因为static 变量的生命周期不受调用堆栈的控制。

void GetSectionStoryGrid_m( int story_number, double *&data, int &len )
{
    static g_data[DATA_SIZE];
    data = g_data;
    // continues ...

如果您想“避免任何分配”，@Speed8ump 的解决方案是您的首选！但是，您将不再拥有您的double * result;。您将把“离线”解决方案（首先计算整个数组，然后在其他地方使用数组）转换为“在线”解决方案（根据需要计算值）。这是避免内存分配的良好重构。

Answer 3

此问题的答案取决于您想要指向的 doubles 的生命周期。考虑：

// "pointless" because it takes no input and throws away all its work
void pointless_function()
{
    double foo = 3.14159;
    int j = 0;
    for (int i = 0; i < 10; ++i) {
        j += i;
    }
}

foo 存在并且在pointless_function 中有一个值，但是一旦函数退出就不再存在。即使您可以获得指向它的指针，该指针在pointless_function 之外也是无用的。这将是一个悬空指针，取消引用会触发undefined behavior。

另一方面，您是正确的，如果您在内存中有数据（并且您可以保证它的寿命足够长，可以用于您想用它做的任何事情），它可能会很棒想法获取指向该数据的指针，而不是支付复制它的成本。但是，数据比创建它的函数更有效的主要方法是调用new、new[] 或malloc。你真的无法摆脱它。

查看您发布的代码，我不明白您如何避免 new[]-在创建 story 时添加双打。但是您可以稍后获得指向这些双精度的指针，而无需再次调用 new 或 new[]。

---

我应该提到，指向数据的指针可以用来修改原始数据。这通常会导致难以追踪的错误。因此，有时最好支付复制数据的代价（然后您可以随意使用这些数据），或者获取指向 const 的指针（在这种情况下为 const double* 或 double const* ，它们是等价的；如果您尝试更改指向的数据，指向 const 的指针会给您一个编译器错误）。事实上，这种情况经常发生，建议应该颠倒过来：“有几次你不想想要复制或获取指向 const 的指针；在这些情况下，你必须小心点。”