C++中基于std::priority_queue实现按参数排序的结构体队列时的编译错误排查及解决方案咨询

让我们逐个拆解你遇到的问题，一步步把代码修正到符合你的需求：

1. 错误：redefinition of ‘pQueue::pQueue()’ #

问题出在你的头文件file.h里，已经直接定义了构造函数的空实现：

pQueue() { }

而在file.cpp里又重复写了一遍构造函数的实现，导致重复定义。

解决方案：
把头文件里的构造函数改成仅声明，不要在头文件里写实现（除非用inline）：

// file.h里的构造函数改成
pQueue();

另外注意：你原来在构造函数里定义的q是局部变量，函数结束就销毁了，根本存不住数据——这也是后续问题的根源，咱们后面一起调整。

2. 错误：use of deleted function ‘pQueue::pQueue(const pQueue&)’ #

这个错误的核心原因是：std::priority_queue的拷贝构造函数是被隐式删除的（它的设计不鼓励拷贝），而你的pQueue类如果没有自定义拷贝构造函数，编译器尝试自动生成时，会发现无法拷贝类内的队列（哦对了，你现在的队列还不是类成员，是局部变量，这更不对）。

正确的设计思路：
把std::priority_queue<std::pair<int, Category*>>作为pQueue类的私有成员变量，所有入队、出队操作都直接操作这个成员，避免传递队列参数导致的拷贝问题。

同时，如果你不需要拷贝pQueue对象，可以显式禁用拷贝构造和赋值运算符，彻底避免这类错误：

// 在file.h的pQueue类里添加
pQueue(const pQueue&) = delete;
pQueue& operator=(const pQueue&) = delete;

3. 错误：‘q’ was not declared in this scope #

这个错误是因为你在main.cpp里调用pQueue::queueWork(Queue, action, data)时，Queue这个变量根本没声明过。而且queueWork是成员函数，不能直接用pQueue::queueWork调用（除非是静态成员），应该创建一个pQueue的实例，然后调用实例的成员函数。

解决方案：

• 在main.cpp里创建一个pQueue的实例（放在合适的作用域，比如全局）：

pQueue myQueue;

• 调用成员函数时直接用实例，不需要传队列参数（因为队列是类成员）：

myQueue.queueWork(action, data);

修正后的完整代码 #

file.h #

#pragma once
#include <queue>
#include <utility>

// 提前声明Category类，避免未定义错误
class Category;

class pQueue {
public:
    pQueue();
    ~pQueue();

    // 调整函数：直接操作类内队列，不需要传队列参数
    void queueWork(int action, Category* data);
    // 对外提供启动处理队列的接口
    void startWork(bool flag);

private:
    // 队列作为类的私有成员，保证数据持久化
    std::priority_queue<std::pair<int, Category*>> q;
    void doWork(bool flag);

    // 显式禁用拷贝和赋值，避免编译器自动生成
    pQueue(const pQueue&) = delete;
    pQueue& operator=(const pQueue&) = delete;
};

file.cpp #

#include "file.h"
// 这里需要包含Category的定义，比如 #include "Category.h"

pQueue::pQueue() {
    // 队列会默认初始化，无需额外操作
}

pQueue::~pQueue() {
    // 手动释放Category*的内存，避免泄漏
    while (!q.empty()) {
        delete q.top().second;
        q.pop();
    }
}

void pQueue::queueWork(int action, Category* data) {
    // 直接操作类内的成员队列q
    q.emplace(action, data);
}

void pQueue::doWork(bool flag) {
    // 加队列非空判断，避免死循环
    while (!q.empty() && flag) {
        auto queueElement = q.top();
        Category* data = queueElement.second;
        
        // 执行你的业务操作
        // ...
        
        q.pop();
    }
}

void pQueue::startWork(bool flag) {
    // 可以在这里启动线程异步处理队列，比如：
    // std::thread(&pQueue::doWork, this, flag).detach();
    // 或者直接同步调用doWork
    doWork(flag);
}

main.cpp #

#include "file.h"
// 包含Category的定义
// #include "Category.h"

// 创建pQueue实例，放在全局作用域让function能访问
pQueue myQueue;

bool function(Category* data) {
    bool result = false;
    if (data) {
        int action = 1; // 后续可根据逻辑设置不同action值
        myQueue.queueWork(action, data);
        
        // 如果需要立即处理队列，调用startWork
        // myQueue.startWork(true);
        
        // 后续可实现获取结果的逻辑，比如用条件变量或回调
        // result = myQueue.getResult();
    }
    return result;
}

额外说明 #

• 关于排序规则：std::priority_queue默认是大顶堆（action值大的元素优先出队），如果需要小顶堆，修改队列模板参数：

  std::priority_queue<std::pair<int, Category*>, 
                      std::vector<std::pair<int, Category*>>,
                      std::greater<std::pair<int, Category*>>> q;
  

• 关于线程安全：如果function会在多线程中调用，记得给队列加锁（比如std::mutex），避免并发访问问题。

内容的提问来源于stack exchange，提问作者Friday