通过返回 front() 和 pops() 的函数清空 std::queue

Question

我正在编写一个模板类，它应该提供一个防止并发访问的队列，基本上是为了能够编写可以处理具有可变数量的并发工作线程的项目列表的类。

模板类有一个方法：

bool getFront(T &value)
{ CritSectEx::Scope scope(listLock);
  bool ret = false;
    if( !itemList.empty() ){
        value = itemList.front();
        itemList.pop();
        ret = true;
    }
    return ret;
}

锁定队列，如果不为空则取出第一个元素，弹出并返回true，这样每个worker都可以做

    while( getFront(entry) ){
        // do something with entry
        nTreated += 1;
    }
    // exit worker

问题是：我通过value 引用返回这里到底是什么？当我测试这段代码时，我得到一个双重释放错误，因为我使用的类型 T 包含一个指针（我们称之为 B），该指针在其 dtor 中被删除（当 B 未标记为指向全局结构的指针时） ）。该 dtor 已在 getFront() 中的 pop() 期间被调用，这似乎是合乎逻辑的。我注意到类型 T 的 ctor 在从现有实例创建新 T 时都分配了 B 的副本，并且它不会子类化任何可以提供“=”运算符的东西，所以我不确定我会如何结束2 个 T 实例，每个实例都包含相同的 B 值和“我们拥有 B”成员。

我不经常做这种事情，所以我可能在这里忽略了一些东西，但是什么？有什么建议可以解决这个问题吗？

补充观察：似乎总是从队列中弹出的最后一个元素显示此行为。

为了不那么模糊，这里是我使用的 typename T：

struct folder_info
{
    // plenty of members snipped
#ifdef __cplusplus
public:
    folder_info()
    {
        memset( this, 0, sizeof(struct folder_info) );
    }
    folder_info(const struct folder_info *src)
    {
        init(src);
    }
    folder_info(const struct folder_info &src)
    {
        init(&src);
    }
private:
    void init(const struct folder_info *src)
    {
        memcpy( this, src, sizeof(struct folder_info) );
        // we don't duplicate the filetypeslist!
        filetypeslist = NULL;
        filetypeslistlen = filetypeslistsize = 0;
    }
#endif
};

typedef struct FileEntry {
public:
    std::string fileName;
    struct stat fileInfo;
    FolderInfo *folderInfo;
    bool freeFolderInfo;
    FileEntry();
    FileEntry( const char *name, const struct stat *finfo, FolderInfo *dinfo, const bool ownInfo=false );
    FileEntry( const char *name, const struct stat *finfo, FolderInfo &dinfo );
    FileEntry(const FileEntry &ref);
    ~FileEntry();
} FileEntry;

FileEntry::FileEntry()
{
    folderInfo = NULL;
    freeFolderInfo = false;
}

FileEntry::FileEntry( const char *name, const struct stat *finfo, FolderInfo *dinfo, const bool ownInfo )
{
    fileName = name;
    fileInfo = *finfo;
    folderInfo = (ownInfo)? new FolderInfo(dinfo) : dinfo;
    freeFolderInfo = ownInfo;
}

FileEntry::FileEntry( const char *name, const struct stat *finfo, FolderInfo &dinfo )
{
    // creating a FileEntry with a FolderInfo reference always makes a copy
    // of the FolderInfo structure
    FileEntry( name, finfo, new FolderInfo(dinfo), true );
}

FileEntry::FileEntry(const FileEntry &ref)
{
    fileName = ref.fileName;
    fileInfo = ref.fileInfo;
    if( ref.freeFolderInfo ){
        folderInfo = new FolderInfo(ref.folderInfo);
    }
    else{
        folderInfo = ref.folderInfo;
    }
    freeFolderInfo = ref.freeFolderInfo;
}

FileEntry::~FileEntry()
{
    if( freeFolderInfo && folderInfo ){
        delete folderInfo;
        folderInfo = NULL;
    }
}

Answer 1

如果我做对了，问题是缺少FileEntry 的用户定义赋值运算符。

如果复制的FileEntry 具有freeFolderInfo == true，则您的复制构造函数会处理每个FileEntry 具有新的FolderInfo 的事实，而您的赋值运算符则没有。

如果您将一个 FileEntry 分配给另一个 freeFolderInfo == true，则您将删除同一个指针两次，只要两者中的最后一个超出范围/被删除。

What is The Rule of Three?

如果您需要自己显式声明析构函数、复制构造函数或复制赋值运算符，您可能需要显式声明所有这三个。

Answer 2

“问题是：我通过值引用返回这里到底是什么？”

如果输出参数没有改变，调用者主要负责传入的值。虽然在完成任何操作之前分配一个适当的默认值可能会更好：

bool getFront(T &value)
{ 
  value = T(); // <<<<< Reset the output
//^^^^^^^^^^^^
  CritSectEx::Scope scope(listLock);
  bool ret = false;
    if( !itemList.empty() ){
        value = itemList.front();
        itemList.pop();
        ret = true;
    }
    return ret;
}

对于指针，这将导致nullptr 设置为value，这不会导致delete 出现问题。

您的双重删除问题很可能是因为在调用 getFront() 之前未正确初始化/重置输出值。

---

一般来说，我建议使用smart pointers 而不是原始指针，并尝试自行正确管理动态内存分配和删除。

使用像std::unique_ptr<T> 这样的类型存储在队列中应该可以顺利解决您的问题。