Question

我有可以制作的不同对象。每种对象类型都有不同的成本。我想检查用户是否可以负担特定对象之前创建它。以下方法不符合此要求：

class Costs {
public:
    int oneCost, anotherCostAttribute; // Actual values for both attribute may differ for the objects
}

class Object {
public:
    virtual Costs getCosts() = 0;
} 

class Object_A : public Object {
    // implement getCosts (always the same for all A's)
}

class Object_B : public Object {
    // implement getCosts (always the same for all B's)
}

// Usage:
// I would have to create a specific object just to check the costs:
Object* pObj = new Object_A();
if(avilableResources >= pObj->getCosts()) {
   // Store object, otherwise delete it
}

我的第二个想法是提供虚拟静态函数的某种基类，但这对C ++来说是不可能的：

class Object {
public:
    virtual static Costs getCosts() = 0;
}

仅使用静态费用属性不允许区分子类费用：

class Object {
public:
    static Costs m_costs; // All objects (A,B,...) would cost the same
}

将费用直接与对象相关联的正确方法是什么？

Answer 1

您可以通过模板提供此信息：

template <typename CostsT>
struct Object {
  static CostsT m_costs;
};

例如，你可以有一个基础Costs类：

struct Costs {
  virtual int oneCost() = 0;
  virtual int anotherCost() = 0;
};

并使用Costs的特定类型的子类声明对象：

struct Costs_A: Costs {
  virtual int oneCost() override { return 1; }
  virtual int anotherCost() override { return 2; }
};
using Object_A = Object<Costs_A>;

这样，您可以在决定是否实例化Object_A之前检索特定的Costs实例：

Costs costsA = Object_A::m_costs;

Answer 2

静态功能不能是虚拟的，但仍可以覆盖。简单地说，正在使用的版本不依赖于对象的实际类，而只依赖于用于访问它的指针的声明类。

但是这可以用来在创建对象之前进行测试：

class ObjectA: public Object {
    ...
public:
    static int getCost() {
        return 10;
    }
    ...
};

class ObjectB: public Object {
    ...
public:
    static int getCost() {
        return 20;
    }
    ...
};

然后：

Object *pObj;
if (availableResources >= ObjectA::getCost()) {  // correctly calls the expected function
    pObj = new ObjectA();
}

您必须知道pObj->getCost()将独立于实际类返回Object版本 - 您甚至可以在getCost类中声明Object以提高编译时间如果您尝试使用它，则会出错。

静态基类属性，在子类中具有不同的值

2 个答案: