是否有可能避免将传递给保存指针的函数复制传递给它的函数？

Question

我有一个类holder的vector，该向量具有从同一抽象基础类（base）派生的不同类（例如）的实例（例如）。我将其构建为基础阶级的指针，以支持多态性。通过称为add的方法添加新实例。呼叫添加时，新类是在括号内构造的，并且未命名（此机制提供给我，无法更改）。

我不太了解该构建类的寿命是什么，以及在退出添加后如何防止其破坏。它必须构建，因此是否有一种方法可以保持其活力并持有有效的指针？还是我必须创建一个副本并让通过的临时死亡？

我使用的是C ++ 17，我的类都没有手动分配内存，仅使用STL容器和原始数据类型。我一直在寻找std :: move（），但是我找不到所需的东西。示例代码：

class Base
{
public:
  std::vector<int> vec;
  virtual void foo() = 0;
}
class Derived : public Base
{
public:
  Derived(int a, int b)
  {
    vec.push_back(a);
    vec.push_back(b);
  }
  void foo() override;
}
class Holder
{
public:
  std::vector<Base*> ptrs;
  void add(Base& arg)     // What should be the type of arg? (Does not have to be Base&)
  {
    ptrs.push_back(&arg); // How should I add a pointer to arg into ptrs so that
                          // arg stays alive after returning from this method?
  }
}
int main()
{ 
  Holder h;
  h.add(Derived(1, 2));   // this is how add() gets called, I cannot change it
  ...
}

编辑：要澄清，我可以更改add的签名和正文，以及vector ptrs使用的数据类型。我无法更改add的方式（h.add（derived（1，2））;）。

Answer 1

在main中，

传递的参数是在调用添加返回之后被暂时销毁的。您可以存储此值，地址，但是您绝对不能解雇它。

如果要确保对象在holder的寿命中保持有效，那么您唯一的选择是接管现有对象的所有权或制作拥有您拥有的副本。

使用std :: unique_ptr将现有对象的所有权

，可以使所有权明确。

class Holder
{
    ...
    void add(std::unique_ptr<Base>&& arg)
    {
        //preferrably make ptrs a std::vector<std::unique_ptr<Base>> and use ptrs.emplace_back(std::move(arg)) or
        ptrs.push_back(args.get());
        args.release(); // make sure the object gets deleted before or during destruction of the Holder object
    }
};

制作副本

在此处使用移动构造函数在此处无效

class Holder
{
    ...

    template<class T>
    void add(T&& arg)     // What should be the type of arg?
    {
        ptrs.push_back(new T(std::forward<T>(arg));
        // Note: make sure the object created here gets destroyed
    }
};

---

编辑

根据更新的答案，这是holder我将继续执行的实现：

class Holder
{
public:
    std::vector<std::unique_ptr<Base>> ptrs; // make this private?

    template<class T>
    void add(T&& arg)
    {
        // better compiler error on incorrect use
        static_assert(std::is_base_of_v<Base, T>,
                      "parameter passed must be an object of a class derived from Base");

        ptrs.reserve(ptrs.size() + 1); // if an std::bad_alloc happens, this gives you a strong exception guarantee
        
        ptrs.emplace_back(std::make_unique<T>(std::forward<T>(args)));
    }
};

注意：这仅适用于base的虚拟破坏者;如果这不是一个选项，则需要保存逻辑，以与对象并肩调用正确的破坏者。您不会阻止创建临时派生的对象，但至少可以使用隐式创建的移动构造函数的派生来防止base :: vec