节点插入cpp

Question

如何在一个函数中编写这3个成员函数的定义？如果是possible.Can，你也解释你是怎么做的，it?.Sorry，我不擅长英语，也不擅长编程，请不要侮辱我。

 void insert(int idx, PW* obj) 
{
    idx--;
    double bd = summaryCost();
    node x(1);
    x.p = obj;

    if (bd + obj->getCost() <= budget) {
        if (idx <= vec.size()) {
            vec.insert(vec.begin() + idx, x);
            remain -= obj->getCost();
        } else {
            delete obj;
            throw IndexOut();
        }
    } else {
        delete obj;
        throw DeficitError();
    }
}

   void insert(int idx, FW* obj) {
    idx--;
    double bd = summaryCost();
    node x(2);
    x.f = obj;
    if (bd + obj->getCost() <= budget) {
        if (idx <= vec.size()) {
            vec.insert(vec.begin() + idx, x);
            remain -= obj->getCost();
        } else {
            delete obj;
            throw IndexOut();
        }
    } else {
        delete obj;
        throw DeficitError();
    }
}

void insert(int idx, TW* obj) {
    idx--;
    double bd = summaryCost();
    node x(3);
    x.t = obj;
    if (bd + obj->getCost() <= budget) {
        if (idx <= vec.size()) {
            vec.insert(vec.begin() + idx, x);
            remain -= obj->getCost();
        } else {
            delete obj;
            throw IndexOut();
        }
    } else {
        delete obj;
        throw DeficitError();
    }
}

Answer 1

如果PW、FW和TW没有通用的基类，您可以使用特征类和模板。

完整示例：

// Empty types for illustration purposes.
struct PW {};
struct FW {};
struct TW {};

struct node
{
    node(int i) {}
    PW* p;
    FW* f;
    TW* t;
};

// For readability improvement.
template<typename T>
using member_ptr = T* node::*;

template<typename T>
struct NodeTraits {};

// Class-specific traits
template<>
struct NodeTraits<PW> {
    enum {value = 1};
    static member_ptr<PW> member;
};

template<>
struct NodeTraits<FW> {
    enum {value = 2};
    static member_ptr<FW> member;
};

template<>
struct NodeTraits<TW> {
    enum {value = 3};
    static member_ptr<TW> member;
};

member_ptr<PW> NodeTraits<PW>::member = &node::p;
member_ptr<FW> NodeTraits<FW>::member = &node::f;
member_ptr<TW> NodeTraits<TW>::member = &node::t;

// Finally, the function...
template<typename T>
void insert(int idx, T* obj) 
{
    node x(NodeTraits<T>::value);
    member_ptr<T> ptr = NodeTraits<T>::member;
    x.*ptr = obj;
    // ...
}

// Using it...
int main()
{
    PW p;
    FW f;
    TW t;
    insert(0, &p);
    insert(0, &f);
    insert(0, &t);
}

将解释留给感兴趣的读者作为练习。

Answer 2

看一下您的dropbox代码，您似乎需要花更多的时间来研究虚拟函数和c++纯虚拟函数；它们允许您执行以下操作

struct ChargeableItem {
  virtual int getCost() = 0;
};

struct WorkItem : ChargeableItem {
  virtual int getCost() {return 5;}
}

int total = 0;
void insert(ChargeableItem* i) {
  total += i->getCost();
}

int main() {
  WorkItem x;
  insert(&x);
}

注意在上面的代码中有很多不好的做法，但我认为这是你最终想要做的。