Question

我有一个这样的班级：

class MyClass : public BaseClass {
public:
  double get_e() { return m_e };
  double set_e(double) { m_e = e};
  double get_f1() { return f_1 };
  // ... things can be a bit more complicated,
  // e.g. non 1-1 mapping between get/set-ers and private fields
private:
  double m_e;
  double m_f1; // many other fields
};

和一个外部功能

void very_slow(MyClass& c) {
 // slow computation based on get_f1(), ...
 // call c.set_e
}

我想把它们放在一起，但是以一种懒惰的方式：

class MyLazyClass : public MyClass {
public:
   double get_e() {
     if (m_calibrated) return m_e;
     else {
        set_e(very_slow(*this));
        m_calibrated = true;
        return get_e();
     }
   }
private:
     m_calibrated = false;
};

我的主要代码如下：

ObjectContainer* objects = nullptr;
retrieve_objects(&objects); // a container of pointers to MyClass
for (MyClass* obj_ptr : objects) {
    // ... maybe decide to skip this object (continue)
    very_slow(*obj_ptr);
    // ... use obj_ptr->get_e()
}

ObjectContainer类型和retrive_objects由我的框架提供，我无法更改它们。如果我想使用MyLazyClass，那么天真的方法是创建副本

ObjectContainer* objects = nullptr;
retrieve_objects(&objects);
for (MyClass* obj_ptr : objects) {
    MyLazyClass obj_lazy(*obj_ptr);
    // ... use obj_lazy->get_e()
}

您可以想象此副本效率很低，我想避免这种情况。有什么解决方案？一个解决方案可能是move-constructor，可以举个例子吗？其他方法？我想定义一个retrive_objects_lazy

Answer 1

您可以想象此副本效率很低

您仅显示了MyClass的两个双子对象（和一个基数，可能为空，也可能不为空）。从我们所看到的情况来看，我可以想象复制非常有效。

一个解决方案可能是move-constructor

就您所显示的成员而言，复制与移动相同，因此不会有任何区别。除非有些子对象复制缓慢，否则您不会显示。

您可以做的是定义

class MyLazyClassContainer {
    ObjectContainer* objects;
    std::vector<bool> calibrated;
    // ...
};

这样，您可以直接将对象检索到自定义类中而无需复制。

在C ++中将对象转换为派生类型

1 个答案: