c++ - for 循环期间的动态分配会造成内存泄漏吗？

Question

我在解决动态分配问题时遇到了问题...我有一个函数 reduce它累积值，在这种情况下，我正在迭代 boost::tuple<double*,double*>的。我的问题在这里:

//executes this code in chunks, asynchronously
boost::tuple<double*,double*> res = hpx::parallel::reduce(hpx::parallel::par,
    iter, iter+4,                                                         
    boost::make_tuple<double*,double*>(g,h), [](reference a, reference b) { 
        double *res= new double;  //dynamic allocation! I don't have anyway to delete this memory afterwards
        *res = *boost::get<1>(b) * *boost::get<0>(b);
        return boost::make_tuple<double*,double*>(res,res); });

函数参数为

template< typename ExPolicy, typename Iter, typename T, typename Func>
T reduce(ExPolicy execution_policy, Iter being, Iter end, T && start, Func && op)

如何通过动态分配变量来避免可能造成内存泄漏，但仍然能够用两个指针填充元组？

Answer 1

我更愿意将其视为 double 元组(或其数组)；它消除了由指向 double 的指针元组创建的所有猜测。

与其将此视为潜在的泄漏，不如从所有权的角度来考虑。当您声明类型为 double 的局部变量时，堆栈拥有它，它将被清理。当您创建类型之一时 double* ，堆栈拥有指针但不拥有值，因此可能不会清理值。显然只是声明一个 double更简单、更容易，所以如果可以的话，请选择它。

现在考虑其他潜在所有者。包含 POD 类型的元组，例如 std::tuple<double, double>会拥有然后清理 double ，但包含指针类型的元组不清楚。清理 std::tuple<double*, double*>不会清理 double 。显然，仅使用 double 元组更简单、更容易，因此如果可以的话，请选择它。

但是，由于各种原因，我假设您必须使用指向 double 的指针元组。

然后考虑您的基础数据需要多长的生命周期。怎样才能得到这一生？您能否将 double 的所有权赋予将在正确的时间清理的其他对象，并将它们的地址存储在元组的非拥有指针中以指向 double ？例如，让您的 lambda 通过引用捕获外部容器，并将您的 double 放入其中，并仅将它们的地址存储在元组中。

这里试图展示我的意思......但是在我展示它时要小心使用 vector 。我对hpx::parallel::reduce一无所知，但我认为它的并行性质会使这个简化版本完全不安全。对 push_back 的两次交错调用和 back将导致创建不正确的元组；对 push_back 的两次重叠调用很容易破坏 vector 。更复杂的版本可以同步其对容器的使用。

std::vector<double> v; // XXX: probably unsafe for parallel reduce

boost::tuple<double*,double*> res = hpx::parallel::reduce(hpx::parallel::par,
    iter, iter+4,                                                         
    boost::make_tuple<double*,double*>(g,h), [&v](reference a, reference b) { 
        v.push_back(*boost::get<1>(b) * *boost::get<0>(b));
        return boost::make_tuple<double*,double*>(&v.back(), &v.back()); });