Verweis auf nicht-statische Funktion muss aufgerufen werden,

Question

ich versucht, einen priority_queue zu erklären:

std::priority_queue<int, std::vector<int>, std::function<bool(int, int)>> m_openList; 

und die Art, wie ich es verwenden, zu initialisieren ist:

m_openList = std::priority_queue<int, std::vector<int>, std::function<bool(int,int)>>(keyCompare); 

keyCompare ist eine Funktion:

bool PathPlanManager::keyCompare(int pointer1, int pointer2) { 
    return m_mapNode[pointer1] > m_mapNode[pointer2];} 

Aber es scheint falsch. BTW, wie kann ich diese priority_queue löschen?

Nachdem ich versuchte, mein Code wie folgt war:

class PathPlanManager { 
public: 
class KeyCompare { 
    public: 
     KeyCompare(PathPlanManager& manager) : m_manager(&manager){} 
     bool operator() (int pointer1, int pointer2) { 
      return m_manager->m_nodeMap[pointer1] < m_manager->m_nodeMap[pointer2]; 
     } 
    private: 
    PathPlanManager* m_manager; 
    }; 
    void init() { 
     m_nodeMap.resize(100); 
     for (int i = 0; i < 100; i++) { 
      m_nodeMap[i] = 100 - i; 
     } 
     m_openList = std::priority_queue<int, std::vector<int>, KeyCompare>(); 
    } 
private: 
    vector<int> m_nodeMap; 
    std::priority_queue<int, std::vector<int>, KeyCompare> m_openList; 
}; 

Und wenn ich es zu bauen versuchte, es ist ein Fehler, sagt kein passender Konstruktor zur Initialisierung von ‚value_compare‘ (auch bekannt als ‚PathPlanManager :: KeyCompare ‚)

Answer 1

KeyCompare braucht ein Objekt von PathPlanManager:

class PathPlanManager { 
public: 
    class KeyCompare { 
    public: 
     KeyCompare(PathPlanManager& manager) : m_manager(&manager) { } 
     bool operator()(int pointer1, int pointer2) { 
      return m_manager->m_mapNode[pointer1] > m_manager->m_mapNode[pointer2]; 
     } 
    private: 
     PathPlanManager* m_manager; 
    }; 
private: 
    std::vector<int> m_mapNode; 
    typedef std::priority_queue<int, std::vector<int>, KeyCompare> mypq_type; 
    mypq_type m_openList; 
} 

Beispiel Nutzung:

PathPlanManager mgr; // somewhere this is initialised 
... 
// want to sort some entries according to mgr 
std::vector<int> entries{ 0, 13, 37, 42 }; 
std::sort(entries.begin(), entries.end(), PathPlanManager::KeyCompare(mgr)); 
// now entries is sorted according to mgr 

nach dem Update zu sehen: Wenn Sie priority_map als Mitglied einer Klasse verwendet werden soll (wir es Planner nennen) Sie es wie folgt tun:

class Planner { 
public: 
    Planner(PathPlanManager& mgr); 
private: 
    std::priority_queue<int, std::vector<int>, PathPlanManager::KeyCompare> m_openList; 
} 

Planner::Planner(PathPlanManager& mgr) 
: m_openList(PathPlanManager::KeyCompare(mgr)) 
{ } 

// Usage: 
... 
PathPlanManager mgr; 
Planner planner(mgr); 
...