我怎样才能解决这个模棱两可的问题呢?mem_fun

为了练习，我再次熟悉的主题之一是树。深度优先搜索和宽度优先搜索的区别在于，它们只在选择支持算法的数据结构上有所不同。

我想我可以写一个普通的树搜索，我将提供堆栈(DFS)或队列(BFS)使用模板。stack和queue很好，它们的添加和删除成员具有相同的名称。不幸的是，访问函数一度被称为top和front。正因为如此，我没有完全到达我想要的地方。没有lambda:

template<typename T, typename D, typename G>
bool ts(Tree<T> const & tree, T const value, D & ds, G getter)
{
    if (empty(tree))
    {
        return false;
    }
    ds.push(tree.Root);
    while (!ds.empty())
    {
        auto const current = getter();
        ds.pop();
        if (current->Value == value)
        {
            return true;
        }
        if (current->Left)
        {
            ds.push(current->Left);
        }
        if (current->Right)
        {
            ds.push(current->Right);
        }
    }
    return false;
}
template<typename T>
bool dfs(Tree<T> const & tree, T const value)
{
    stack<typename Tree<T>::Node const * const> ds;
    return ts(tree, value, ds, [&ds](){ return ds.top(); });
}
template<typename T>
bool bfs(Tree<T> const & tree, T const value)
{
    queue<typename Tree<T>::Node const * const> ds;
    return ts(tree, value, ds, [&ds](){ return ds.front(); });
}

我认为我应该能够使用mem_fun(或mem_fun_ref)来提供相应的访问功能。我试着

template<typename T>
bool dfs(Tree<T> const & tree, T const value)
{
    typedef stack<typename Tree<T>::Node const * const> DataStructure;
    return ts(tree, value, DataStructure(), mem_fun(&DataStructure::top));
}

但是随后编译器抱怨有歧义(在const和非const版本之间)。

所以我搜索了互联网，了解到我应该明确地提供模板类型。

template<typename T>
bool dfs(Tree<T> const & tree, T const value)
{
    typedef stack<typename Tree<T>::Node const * const> DataStructure;
    return ts(tree, value, DataStructure(), mem_fun</*???*/>(&DataStructure::top));
}

更新:这里有一个完整的工作示例(除非您定义了NO_LAMBDA):

#include <iostream>
#include <stack>
#include <functional>
using namespace std;
template<typename T>
struct Tree
{
    struct Node
    {
        T Value;
        Node * Left;
        Node * Right;
        Node(T value) : Value(value), Left(nullptr), Right(nullptr) {}
        virtual ~Node()
        {
            if (Left) delete Left;
            if (Right) delete Right;
        }
    };
    Node * Root;
    Tree() : Root(nullptr) {}
    virtual ~Tree() { if (Root) delete Root; }
};
template<typename T> void insert(typename Tree<T>::Node * node, T const & value)
{
    typename Tree<T>::Node ** selected = &(value < node->Value ? node->Left : node->Right);
    if (*selected)
        insert(*selected, value);
    else
        *selected = new typename Tree<T>::Node(value);
}
template<typename T> void insert(Tree<T> & tree, T value)
{
    if (!tree.Root)
        tree.Root = new typename Tree<T>::Node(value);
    else
        insert(tree.Root, value);
}
template<typename T, typename D, typename G>
bool ts(Tree<T> const & tree, T const value, D & ds, G getter)
{
    if (!tree.Root) return false;
    ds.push(tree.Root);
    while (!ds.empty())
    {
        auto const current = getter();
        ds.pop();
        if (current->Value == value) return true;
        if (current->Left) ds.push(current->Left);
        if (current->Right) ds.push(current->Right);
    }
    return false;
}
template<typename T>
bool dfs(Tree<T> const & tree, T const value)
{
    typedef typename Tree<T>::Node const * DataStructureContent;
    typedef stack<DataStructureContent> DataStructure;
#ifdef NO_LAMBDA // With this defined, it breaks.
    return ts(tree, value, DataStructure(),
        mem_fun(static_cast<DataStructureContent (DataStructure::*)() const>(&DataStructure::top)));
#else // This works.
    DataStructure ds;
    return ts(tree, value, ds, [&ds] () { return ds.top(); });
#endif
}
int main()
{
    Tree<int> tree;
    insert(tree, 5);
    insert(tree, 2); insert(tree, 1); insert(tree, 3);
    insert(tree, 7); insert(tree, 6); insert(tree, 9);
    cout << "DFS(7) -> " << dfs(tree, 7) << endl;
    cout << "DFS(8) -> " << dfs(tree, 8) << endl;
    return 0;
}