11

我无法编译我的 C++ 程序。非常感谢有关此错误的一些帮助。在头文件中，我有这个：

struct workerT{
 workerT() : status(true), threadSem(0){}
 bool status;
 std::function<void(void)> func;
 semaphore threadSem;
};

std::vector<workerT> workers;

在我的 .cc 文件中，我试图像这样初始化该向量：

fill(workers.begin(), workers.end(), workerT());

这失败并出现错误：错误：'TP::workerT& TP::workerT::operator=(const TP::workerT&)' 被隐式删除，因为默认定义格式不正确：它指向 semaphore.h 文件. Semaphore.h 的定义如下：

 public:
  semaphore(int value = 0);
  ....

private:
  int value;
  ....
  semaphore(const semaphore& orig) = delete;
  const semaphore& operator=(const semaphore& rhs) const = delete;

如果我删除“填充”行，程序就会编译，但我真的需要它，因为我想初始化向量。当我制作一个虚拟结构并尝试将 push_back 放入向量时，我收到了相同的错误消息。

更新：感谢@DyP！我仍然需要帮助编译。将“填充”行替换为：

std::generate(workers.begin(), workers.end(), free_func);

将其添加到我的标题中：

workerT free_func(){
 return {};
}

收到这些错误：

thread-pool.cc：在构造函数'ThreadPool::ThreadPool(size_t)'中：thread-pool.cc:33:58：错误：'ThreadPool::workerT (ThreadPool::)()' 类型的参数不匹配' ThreadPool::workerT (ThreadPool::*)()' 在来自 /usr/include/c++/4.6/algorithm:63:0 的文件中，来自 thread-pool.cc:15: /usr/include/c++/4.6/ bits/stl_algo.h: 在函数'void std::generate(_FIter, _FIter, _Generator) [with _FIter = __gnu_cxx::__normal_iterator >, _Generator = ThreadPool::workerT (ThreadPool::*)()]'中：线程- pool.cc:33:58：从这里实例化 /usr/include/c++/4.6/bits/stl_algo.h:5013:2: 错误：必须使用 '. ' 或 '-> ' 在 '__gen (...)' 中调用指向成员函数的指针，例如 '(... ->* __gen) (...)' make: * [thread-pool.o ] 错误 1

更新——在我的 .cc 文件中：

 using namespace std;

 static workerT free_func(){
   return {};
 }

 ThreadPool(...args...){
   std::generate(workers.begin(), workers.end(), free_func);
 }

错误：

thread-pool.cc:19:10: error: ‘workerT’ does not name a type
thread-pool.cc: In constructor ‘ThreadPool::ThreadPool(size_t)’:
thread-pool.cc:39:49: error: ‘free_func’ was not declared in this scope
make: *** [thread-pool.o] Error 1

再次更新：

 static ThreadPool::workerT free_func(){
    return {};
 }

 ThreadPool(...args...){
   std::generate(workers.begin(), workers.end(), free_func);
 }

在线程池.h 中：

 struct workerT{
 workerT() : status(true), threadSem(0){}
 bool status;
 std::function<void(void)> func;
 semaphore threadSem;
};
4

1 回答 1

6

正如0x499602d2正确指出的那样，fill需要从第三个参数复制分配。由于您的类型隐式不可复制，因此您不能使用fill.

但是，您可以使用generate来填充您的向量：

#include <vector>
#include <algorithm>

struct noncopyable
{
    noncopyable() = default;

    // make it noncopyable
    noncopyable(noncopyable const&) = delete;
    noncopyable& operator=(noncopyable const&) = delete;

    // make it movable (thanks, gx_)
    noncopyable(noncopyable&&) = default;
    noncopyable& operator=(noncopyable&&) = default;
};

int main()
{
    std::vector<noncopyable> vec(10);
    std::generate(begin(vec), end(vec), []()->noncopyable{return {};});
}

注意：这仅在noncopyable具有未删除的、可访问的移动构造函数时才有效。但是，如果它没有这样的 ctor，您将无法使用大部分向量（resizerequires MoveInsertable，这需要复制或移动 ctor）。

对于 g++4.8，要使用generate，您需要一个免费函数。我认为这是一个错误。

#include <vector>
#include <algorithm>

struct noncopyable
{
    noncopyable() = default;
    noncopyable(noncopyable const&) = delete;
};

noncopyable free_func()
{  return {};  }

int main()
{
    std::vector<noncopyable> vec;
    std::generate(begin(vec), end(vec), free_func);
}

还有一个问题是你是否可以这样初始化你的向量。我会说不。fill并且generate不构造元素，而是覆盖（分配）。也就是说，在使用它们之前，您已经需要一个包含多个元素的向量。

使用 N 个默认构造元素初始化向量的最简单版本是使用构造函数：

std::vector<noncopyable> vec(10);

vector使用 10 个默认构造的元素创建一个。唯一的要求是noncopyableDefaultConstructible （本质上，它必须有一个默认构造函数）。

如果您的类型是不可复制且不可移动的，则不能直接使用它（或作为数据成员）将其存储在vector(*) 中。要使C包含不可复制、不可移动类型的类可移动，X您需要将其存储X为指针：

(*) 好吧，你可以，但你不能调整向量的大小，你不能插入等等。

struct nocopies_nomoves
{
    nocopies_nomoves() = default;

    nocopies_nomoves(nocopies_nomoves const&) = delete;
    nocopies_nomoves& operator=(nocopies_nomoves const&) = delete;

    // not required to be explicitly deleted:
    nocopies_nomoves(nocopies_nomoves&&) = delete;
    nocopies_nomoves& operator=(nocopies_nomoves&&) = delete;
};

#include <utility>
#include <memory>
class C
{
public:
    C() : ptr( new nocopies_nomoves() ) {} // make_unique in C++1y

    // I don't think you need to explicitly define those as defaulted;
    // at least not if you don't declare ANY of the copy/move ctors, assignment ops
    // and dtor
    C(C&& rhs) = default;
    C& operator=(C&& rhs) = default;
    ~C() = default;

    // not required to be explicitly deleted:
    C(C const&) = delete;
    C& operator=(C const&) = delete;
private:
    std::unique_ptr<nocopies_nomoves> ptr;
};

现在您可以创建vector<C>并使用它（例如resize, insert, ...）

#include <vector>
#include <algorithm>

static C generate_C()
{
    return {};
}

int main()
{
    std::vector<C> vec(10);
    // note: futile statement below; overwrites the 10 default-constructed
    //       elements
    std::generate(begin(vec), end(vec), generate_C);
}
于 2013-11-09T21:13:12.433 回答