0

我在这里撞墙了......我不知道如何说出这个问题的标题，因为我不知道如何去寻找解决方案。

我有一个基本模板类（组件），其中包含每个组件类型（如位置、方向、网格）的所有实例的映射。我无法制定一个“迭代”函数，该函数将遍历地图并为每个实例调用一个 void 成员函数（作为迭代函数的参数提供）。我很确定我应该使用函数指针，但是我在网上找到的所有示例都是针对全局函数或非模板类的。

这是基本模板类

typedef unsigned long uuid;

template <class T>
class Component {

public:
    static std::map<uuid, T*> IDS;
    static typename std::map<uuid, T*>::iterator Iterator;
    static T* Create(uuid fID) {
        Component<T>::IDS[fID] = new T(fID);
        return Component<T>::IDS[fID];
    };

    static void Iterate(); //how do I add in void function pointers?
    static bool ifExists(uuid fID);
};

template <typename T>
std::map<uuid, T*> Component<T>::IDS;

template <typename T>
typename std::map<uuid, T*>::iterator Component<T>::Iterator;

template <typename T>
void Component<T>::Iterate() {
    for(Iterator = IDS.begin(); Iterator != IDS.end(); Iterator++) {
        //This references the instance that performs the given function
        //(*Iterator).second
    }
}

这是与模板一起使用的组件的示例。

class COM_Position {
    float x, y, z;
public:
    COM_Position(uuid fID);
    uuid ID;
    void Set(float fX, float fY, float fZ);
    void Display();
};

COM_Position::COM_Position(uuid fID) : ID(fID) {
    x = 0; y = 0; z = 0;
}

void COM_Position::Display() {
    printf("%lu : (%f, %f, %f)", ID, x, y, z);
}

typedef Component<COM_Position> Position;

我将如何创建一个迭代函数，该函数将函数指针作为可应用于每个实例的参数（例如，为每个实例调用 Display）？我希望能够做这样的事情。

int main() {
    for(int ii = 0; ii < 4; ii++) {
        Position::Create(ii);
    }

    /*
    This is what I am aiming for; a clean iterator function
    Position::Iterate(Display());
    */
}

如果这是不可能的，我知道我可以用宏来模拟......

4

1 回答 1

1

像这样的东西？

template <typename T>
void Component<T>::Iterate(void (T::*method)() ) {
    for(Iterator i= IDS.begin(); i != IDS.end(); i++) {
        (i->second->*method)();
    }
}

并迭代：

Position::Iterate( &COM_Position::Display );

编辑：一些neet重载：

使用 C++0x 的可变参数模板，您可以使用一些通用方法。我没有测试它，但它看起来很有希望：

template <typename T, typename... Args>
void Component<T>::Iterate(void (T::*method)(Args... args), Args&&... params) {
    for(Iterator i= IDS.begin(); i != IDS.end(); i++) {
        (i->second->*method)(std::forward<Args>(params)...);
    }
}

大多数函数和仿函数可用于：

template <typename T, typename F>
void Component<T>::Iterate( F func ) { // using generic functor 
    for(Iterator i= IDS.begin(); i != IDS.end(); i++) {
        func(i->second->*method);
    }
}
于 2012-05-22T03:11:30.147 回答