如何设计可以反弹的大物体的依赖性

How to design class dependence on large objects which can be rebound?

本文关键字：大物 依赖性      更新时间：2023-10-16

我需要更改内部变量以引用新对象，然后做某事，然后再次更改对象，然后在新值上做一些事情。

class dml
{
     void setTrain(matrix<T> train_x , matrix<T> train_y)
     {
          train_x_ = train_x;
          train_y_ = train_y;
     }
     void train();
     private:
          matrix<T> train_x_;
          matrix<T> train_y_;
}

所以，我将首先设置火车，然后致电火车，该火车使用我刚刚训练的值。然后，稍后，我可能会通过对新值调用SetTrain来更改值，我想再次在该数据上运行训练。（对于来自ML的人，我想实施迷你批次，在这里进食数据，对其进行训练，然后进食下一批数据，然后对其进行训练）我现在拥有的简单解决方案是愚蠢的，因为它涉及复制一个非常大的矩阵。我的指针是想到的简单解决方案，但我希望不使用它们。我的程序非常复杂，指针和MEM分配只会更麻烦。我的一个想法是：

     private:
          matrix<T>& train_x_;
          matrix<T>& train_y_;
}

course这不起作用，因为参考无法指向零值，我必须在构造函数中初始化它们，并且由于它们不能重新限制，因此使用它们没有意义。

我认为解决方案将是使用一些智能指针。但是智能指针用于管理堆的内存，但我不是在堆中分配内存。矩阵对象是在堆栈中创建的，但是它是使用std :: vector实现的，该vector在堆中初始化了其所有对象。

我认为逻辑上共享的_ptr应该有效，因为我们正在共享一个可变性。std::make_shared似乎是个好主意，但是我读到，当您尝试从堆栈中的现有对象创建共享_ptr时，它也会创建一个副本。但这并不能解决必须复制如此大的对象的问题。

另一个显而易见的是std::move，但移动不适用于此处，因为我可能需要在功能调用之外使用火车数据Agian。

我确定我缺少明显的东西。我现在有点剥夺了睡眠，所以任何解决方案都会对我有很大帮助！

只是为了澄清：

LargeObj a=9;
auto a_ptr=std::make_shared(a);

如果我这样做，那么a_ptr将只指向a，而无需创建副本吗？但这不是这里的答案之一：

创建一个boost :: shared_ptr到现有变量

int a = 3;//现有变量shared_ptr acopy = make_shared（a）;//创建具有

的值的复制
LargeObj a=9;
auto a_ptr=std::make_shared(a);

如果我这样做，那么a_ptr将只指向a，而无需创建一个 复制？

如果您通过从现有对象复制（允许它）来创建共享指针，那么您将有两个对象。可以通过删除类中的相关函数和/或不将对象定义为shared_ptr<matrix<T>>以外的任何东西来避免这种情况。

。

您可以使用大型对象并防止使用std::shared_ptr。

以下是问题中示例的改编。它将对象创建为std::shared_ptr s，并显示如何将它们分配给示例中的类。

#include <memory>
#include <iostream>
#include <string>
template <typename T>
class matrix {
public:
    matrix() = default;
    matrix(const matrix&) = delete; // no copy
    matrix(matrix&&) = default; // allow move
    matrix& operator=(const matrix&) = delete; // no copy
    matrix& operator=(matrix&&) = default; // allow move
};
template <typename T>
class dml
{
public:
    void setTrain(std::shared_ptr<matrix<T>> train_x_ptr, std::shared_ptr<matrix<T>> train_y_ptr)
    {
        train_x_ = train_x_ptr;
        train_y_ = train_y_ptr;
    }
    void train() {};
private:
    std::shared_ptr<matrix<T>> train_x_{}; // starts out as an empty shared pointer (contains nullptr)
    std::shared_ptr<matrix<T>> train_y_{}; // starts out as an empty shared pointer (contains nullptr)
};
int main()
{
    // no explicit new, object is created on the heap (train_x_ptr is created on the stack,
    // but will be copied to dml without copying the underlying object).
    auto train_x_ptr{std::make_shared<matrix<int>>()}; 
    auto train_y_ptr{std::make_shared<matrix<int>>()};
    dml<int> d;
    d.setTrain(train_x_ptr, train_y_ptr);
}

请注意，new不直接使用。

我认为解决方案将是使用一些智能指针。但 智能指针用于管理堆的内存，但我不是 在堆中分配内存。矩阵对象是在 堆栈，但它是使用std :: vector实现的，该vector初始化 其堆中的所有对象。

在此示例中，std::shared_ptr将在堆上创建matrix并为您管理寿命。同时，如果matrix包含std::vector，这些元素也将在某个地方，由std::vector管理。

我认为从逻辑上共享_ptr应该有效，因为我们正在共享 可变。std::make_shared似乎是个好主意，但我读到 当您尝试从现有 堆栈中的对象。但这并不能解决必须 复制如此大的对象。

它不会创建副本。它确实解决了问题。

相关文章：