小编Jes*_*Jes的帖子

我正在实现一个push_back在可调用对象上有一个方法的线程池.但是我在使用lambda技巧将打包的任务移动到函数对象时遇到错误.

class Threadpool {

public:
  // ...
  ::std::deque <::std::function<void()>> _work_queue;
  ::std::mutex _work_queue_mutex;
  ::std::condition_variable _worker_signal;

  template <typename CallableT>
  ::std::future<::std::result_of_t<CallableT()>> push_back(CallableT&&);
}

template<typename CallableT>
::std::future<::std::result_of_t<CallableT()>> Threadpool::push_back(CallableT&& callable) {

  ::std::packaged_task<::std::result_of_t<CallableT()>()> task (::std::move(callable));
  auto fu = task.get_future();

  {
    ::std::unique_lock<::std::mutex> locker(_work_queue_mutex);
    // COMPILE ERROR
    _work_queue.emplace_back([task=::std::move(task)] () { task(); })
  }

  _worker_signal.notify_one();

  return fu; 
}

Threadpool pool;
pool.emplace_back( []() { ::std::cout << "hello\n"; } );

编译器抱怨了emplace_back由error: no match for call to '(const std::packaged_task<void()>) ()' _work_queue.emplace_back([task=::std::move(task)]() { task(); });我不明白发生了什么错误的,因为据我所知packaged_task是唯一可移动的,我通过移动捕获任务.

我对std::function在给定的lambda中构造的方式感到有些困惑.这里std::function列出了构造函数.哪一个实际用于捕获一个lambda？是template< class F > function( F f );吗？看起来我无法std::function使用捕获非可复制构造对象的lambda构造.为什么这对lambda捕获是必要的？

// fu is an object of type std::future 
std::function f = [future=std::move(fu)]() {...}  // compile error

// foo is an object of type int
std::function f = [foo=std::move(foo)]() {...} // compile ok

我正在编写一个程序，该程序使用sendmsg和recvmsg通过域套接字在两个进程之间传递文件描述符。为了发送文件描述符，附加数据包含在msghdr.msg_iov和 中msghdr.msg_iolen。但是，我被告知类似于正常read和write系统调用，sendmsg并且recvmsg也有部分读/写问题。在这种情况下，是否会为每个部分数据自动复制辅助字段中的数据？我问这个是因为我的实现需要非阻塞机制。让我用下面的例子来详细说明一下

发送方：发送msghdr包含fd辅助字段中的 a和K字节中的数据msg_iov

接收器：(1) 部分读取，K1字节 (2) 部分读取，K-K1字节

现在作为上面的例子，当所有数据到达时，我应该在步骤（2）之后实际处理数据。在这种情况下，我还能fd从辅助字段中正确提取吗？还是只出现在第一部分阅读中？

为了格式化 Long 或 Double 类型变量，我应该使用 '%' 之后的后缀是什么？

var LONG : Long = 9L;
println("The value of LONG is %?".format(LONG));
var DOUBLE : Double = 9.9;
println("The value of DOUBLE is %?".format(DOUBLE));

非常感谢。

在 ubuntu 机器上成功安装 Docker（按照官方网站说明https://docs.docker.com/engine/installation/）后，我的 ssh 停止工作A。现在我的笔记本电脑无法通过 ssh 连接，A但可以用于其他机器，例如B，与A. A可以 ssh 到B，B也可以 ssh 到A. 可能是什么问题呢？谁能建议我如何进行诊断？

这可能是一个概念性问题.我正在实现lambda作为参数的函数.但是,我无法理解a的确切类型lambda.例如:

auto T = [] () { printf("hello world\n"); };
auto F = move(T);
T();  // print "hello world"
F();  // print "hello world"

我打完电话后想到move的T,内容T消失了.换句话说,我期望以下行为:

function<void> T = [] () { printf("hello world\n");};
auto F = move(F);
F();  // print "hello world"
T();  // throw error

回到最初的问题,传递/分配lambda给一个类成员的最佳做法是function<void()>什么？我看到了许多不同的答案,一些使用const function<void()>&和其他建议模板F&&

struct Foo {

  function<void()> f;

  // Option 1:
  void set_f(const function<void()>& in) {f=in;}

  // Option …

典型的工厂设计模式需要基类声明虚拟析构函数，但这实际上可以使用shared_ptr.

#include <iostream>
#include <memory>
#include <cstdio>

using namespace std;

class Dog {
  public:
  ~Dog() { cout << "dog destroyed\n"; }
};

class Yellowdog : public Dog {
  public:
  ~Yellowdog() { cout << "Yellow dog destroyed.\n"; }
};

class DogFactory {
  public:
  static shared_ptr<Dog> createYellowdog() { 
    return shared_ptr<Yellowdog>(new Yellowdog()); 
  }
};

int main(int argc, char *argv[]) {

  auto ptr = DogFactory::createYellowdog();
  cout << ptr.use_count() << endl;

  return 0;
}

在这种情况下，输出yellowdog destroyed后跟dog destroyed. 但为什么？为什么 using …

是否可以根据给定的枚举值重载或专门化类成员函数？

enum class Type {
  TypeA,
  TypeB,
  TypeC
};

class Foo {

  public:

  template <Type t, typename R = std::enable_if_t<t==Type::TypeA, int>>
  R get() {
    return 1;
  }

  template <Type t, typename R = std::enable_if_t<t==Type::TypeB, double>>
  R get() {
    return 2;
  }

  template <Type t, typename R= std::enable_if_t<t==Type::TypeC, float>>
  R get() {
    return 3;
  }
};

Foo foo;

std::cout << foo.get<Type::TypeA>() << std::endl;
std::cout << foo.get<Type::TypeB>() << std::endl;
std::cout << foo.get<Type::TypeC>() << std::endl;

编译抱怨上面的代码片段重载.

我想知道从正在运行的进程执行新进程（程序）的最佳实践是什么。更具体地说，我正在实现一个 C/C++ 作业调度程序，它必须在与多个二进制文件通信时运行它们。是exec或fork普遍吗？或者有没有图书馆负责这个？

所以,C++ 14提供结构make_index_sequence<N>用于从生成索引序列0到N-1.我想知道如何实现一个生成给定范围内的索引序列.例如:

template <size_t Min, size_t Max>
struct make_index_range;  

// make_index_range<5, 9> will give index_sequence<5, 6, 7, 8>