Question

我需要更改内部变量以引用新对象，然后执行某些操作，然后再次更改对象，然后对新值执行某些操作。

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的人，我想实现迷你批次，在那里我提供数据，在其上训练，然后输入下一批数据，然后训练它）我现在拥有的简单解决方案是愚蠢的，因为它涉及复制一个非常大的矩阵。我指出了想到的简单解决方案，但我不想使用它们。我的程序非常复杂，指针和内存分配只会比较麻烦。我想的一个想法是：

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

当然这不起作用，因为引用不能指向null值，我必须在构造函数中初始化它们，因为它们不能被重新绑定，所以使用它们没有意义。

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

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

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

我确信我错过了一些明显的东西。我现在睡不着觉，所以任何解决办法都会帮助我很多！

只是为了澄清：

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

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

Create a boost::shared_ptr to an existing variable

int a = 3; //现有变量 shared_ptr aCopy = make_shared（a）; //创建值为

的副本

Answer 1

LargeObj a=9;
auto a_ptr=std::make_shared(a);
如果我这样做，那么a_ptr只会指向a，而不会创建一个副本？

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

如果您使用std::shared_ptr，则可以使用大型对象并阻止复制。

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

#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实现的，它初始化堆中的所有对象。

在此示例中，std::shared_ptr将在堆上创建matrix并为您管理生命周期。同时，如果matrix包含std::vector，则这些元素也将位于堆上的某个位置，由std::vector管理。

我认为逻辑上shared_ptr应该有效，因为我们正在分享 varaible。 std::make_shared似乎是一个好主意，但我读到了它当您尝试从现有创建shared_ptr时，也会创建副本堆栈中的对象。但这并没有解决必须解决的问题复制这么大的物体。

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

如何设计对可以反弹的大型物体的类依赖？

1 个答案: