C++ 使用成员函数重载布尔运算符

我有一门课是这样的：

    class AI
    {
    private:
        struct Comparator
        {
            bool operator()(const Town* lfs, const Town* rhs)
            {
                return GetHeuristicCost(lfs) > GetHeuristicCost(rhs);
            }
        };
int GetHeuristicCost(const Town* town);
    // constructor and variables
    };

struct Comparator1
{
    bool operator()(const Town* lfs, const Town* rhs)
    {
        return GetHeuristicCost(lfs) > GetHeuristicCost(rhs);
    }
};

struct Comparator2
{
    bool operator()(const Town* lfs, const Town* rhs)
    {
        return GetHeuristicCost(lfs) + GetTotalCost (lfs, rhs) > GetHeuristicCost(rhs) + GetTotalCost (lfs, rhs);
    }
};

GetHeuristicCost

将启发式从town参数返回到路径的

exit

我试图做的是重载优先级队列的bool操作符，但它给了我一个错误

a nonstatic member reference must be relative to a specific object

我知道它为什么会给我这个错误，但我不知道的是如何在

比较器

结构中使用非静态函数

GetHeuristicCost

必须是非静态的

我尝试将

GetHeuristicCost

移动到

Town

类中，但没有成功

我需要用一个struct重载操作符，因为我需要在

（）

上使用两个不同的bool重载，用于两种不同的情况，但参数相同（两个镇）。换句话说，我需要结构，所以我不能这样做：

布尔运算符（）（常数镇*lfs，常数镇*rhs） { 返回GetHeuristicCost（lfs）>GetHeuristicCost（rhs）； }

基本上，我计划有两个这样的结构：

    class AI
    {
    private:
        struct Comparator
        {
            bool operator()(const Town* lfs, const Town* rhs)
            {
                return GetHeuristicCost(lfs) > GetHeuristicCost(rhs);
            }
        };
int GetHeuristicCost(const Town* town);
    // constructor and variables
    };

struct Comparator1
{
    bool operator()(const Town* lfs, const Town* rhs)
    {
        return GetHeuristicCost(lfs) > GetHeuristicCost(rhs);
    }
};

struct Comparator2
{
    bool operator()(const Town* lfs, const Town* rhs)
    {
        return GetHeuristicCost(lfs) + GetTotalCost (lfs, rhs) > GetHeuristicCost(rhs) + GetTotalCost (lfs, rhs);
    }
};

---

您需要使用指向其“外部”类实例的指针/引用来构造Comparator嵌套类的实例

class AI
{
private:
    struct Comparator
    {
        const AI &outer;

        Comparator(const AI &o):outer(o){}

        bool operator()(const Town* lfs, const Town* rhs)const
        {
            return outer.GetHeuristicCost(lfs) > outer.GetHeuristicCost(rhs);
        }
    };

    int GetHeuristicCost(const Town* town)const;
};

// how to use in code:
AI::Comparator comp(*this);
priority_queue<Town*, vector<Town*>, AI::Comparator> priorityQueue(comp);

AI类
{
私人：
结构比较器
{
康斯特艾和外；
比较器（常数AI&o）：外部（o）{}
布尔运算符（）（常数镇*lfs，常数镇*rhs）常数
{
返回outer.GetHeuristicCost（lfs）>outer.GetHeuristicCost（rhs）；
}
};
int GetHeuristicCost（施工镇*施工镇）施工；
};
//如何在代码中使用：
AI：：比较器组件（*本）；
优先级队列优先队列（comp）；

您需要使用指向其“外部”类实例的指针/引用来构造Comparator嵌套类的实例

class AI
{
private:
    struct Comparator
    {
        const AI &outer;

        Comparator(const AI &o):outer(o){}

        bool operator()(const Town* lfs, const Town* rhs)const
        {
            return outer.GetHeuristicCost(lfs) > outer.GetHeuristicCost(rhs);
        }
    };

    int GetHeuristicCost(const Town* town)const;
};

// how to use in code:
AI::Comparator comp(*this);
priority_queue<Town*, vector<Town*>, AI::Comparator> priorityQueue(comp);

AI类
{
私人：
结构比较器
{
康斯特艾和外；
比较器（常数AI&o）：外部（o）{}
布尔运算符（）（常数镇*lfs，常数镇*rhs）常数
{
返回outer.GetHeuristicCost（lfs）>outer.GetHeuristicCost（rhs）；
}
};
int GetHeuristicCost（施工镇*施工镇）施工；
};
//如何在代码中使用：
AI：：比较器组件（*本）；
优先级队列优先队列（comp）；

您需要使用指向其“外部”类实例的指针/引用来构造Comparator嵌套类的实例

class AI
{
private:
    struct Comparator
    {
        const AI &outer;

        Comparator(const AI &o):outer(o){}

        bool operator()(const Town* lfs, const Town* rhs)const
        {
            return outer.GetHeuristicCost(lfs) > outer.GetHeuristicCost(rhs);
        }
    };

    int GetHeuristicCost(const Town* town)const;
};

// how to use in code:
AI::Comparator comp(*this);
priority_queue<Town*, vector<Town*>, AI::Comparator> priorityQueue(comp);

AI类
{
私人：
结构比较器
{
康斯特艾和外；
比较器（常数AI&o）：外部（o）{}
布尔运算符（）（常数镇*lfs，常数镇*rhs）常数
{
返回outer.GetHeuristicCost（lfs）>outer.GetHeuristicCost（rhs）；
}
};
int GetHeuristicCost（施工镇*施工镇）施工；
};
//如何在代码中使用：
AI：：比较器组件（*本）；
优先级队列优先队列（comp）；

您需要使用指向其“外部”类实例的指针/引用来构造Comparator嵌套类的实例

class AI
{
private:
    struct Comparator
    {
        const AI &outer;

        Comparator(const AI &o):outer(o){}

        bool operator()(const Town* lfs, const Town* rhs)const
        {
            return outer.GetHeuristicCost(lfs) > outer.GetHeuristicCost(rhs);
        }
    };

    int GetHeuristicCost(const Town* town)const;
};

// how to use in code:
AI::Comparator comp(*this);
priority_queue<Town*, vector<Town*>, AI::Comparator> priorityQueue(comp);

AI类
{
私人：
结构比较器
{
康斯特艾和外；
比较器（常数AI&o）：外部（o）{}
布尔运算符（）（常数镇*lfs，常数镇*rhs）常数
{
返回outer.GetHeuristicCost（lfs）>outer.GetHeuristicCost（rhs）；
}
};
int GetHeuristicCost（施工镇*施工镇）施工；
};
//如何在代码中使用：
AI：：比较器组件（*本）；
优先级队列优先队列（comp）；

我尝试在我的一个函数中使用它，比如

Comparator（*this）优先级队列优先级队列

但是它给了我一个错误，comp不是一个类型namepriority\u queuepriorityQueueI尝试过，但它不喜欢我没有创建Comparator实例的事实。它给我的错误是不存在默认构造函数。我也不知道这是否重要，但我从

AI&outer

和

AI&o

中删除了

const

，因为我的AI对象不断变化。请参阅我的编辑。当然你的人工智能会不断变化，但是GetHueristicCost真的会修改它吗？如果您正在执行类似于*的操作，那么它可能是一个只读操作。我尝试在我的一个函数中使用它，例如

Comparator comp（*this）优先级队列优先级队列

但是它给了我一个错误，comp不是一个类型namepriority\u queuepriorityQueueI尝试过，但它不喜欢我没有创建Comparator实例的事实。它给我的错误是不存在默认构造函数。我也不知道这是否重要，但我从

AI&outer

和

AI&o

中删除了

const

，因为我的AI对象不断变化。请参阅我的编辑。当然你的人工智能会不断变化，但是GetHueristicCost真的会修改它吗？如果您正在执行类似于*的操作，那么它可能是一个只读操作。我尝试在我的一个函数中使用它，例如

Comparator comp（*this）优先级队列优先级队列

但是它给了我一个错误，comp不是一个类型namepriority\u queuepriorityQueueI尝试过，但它不喜欢我没有创建Comparator实例的事实。它给我的错误是不存在默认构造函数。我也不知道这是否重要，但我从

AI&outer

和

AI&o

中删除了

const

，因为我的AI对象不断变化。请参阅我的编辑。当然你的人工智能会不断变化，但是GetHueristicCost真的会修改它吗？如果您正在执行类似于*的操作，那么它可能是一个只读操作。我尝试在我的一个函数中使用它，例如

Comparator comp（*this）优先级队列优先级队列

但是它给了我一个错误，comp不是一个类型namepriority\u queuepriorityQueueI尝试过，但它不喜欢我没有创建Comparator实例的事实。它给我的错误是不存在默认构造函数。我也不知道这是否重要，但我从

AI&outer

和

AI&o

中删除了

const

，因为我的AI对象不断变化。请参阅我的编辑。还要确保你的人工智能不断变化，