为什么通过通用引用运算符 (&&) 将变量引用传递给可变参数模板函数失败？

Question

我打算将一个变量的引用传递给一个成员函数指针，它是另一个varadic模板函数的参数来调用class的任何类型的成员函数，但是从打印结果来看，它不是按引用传递，而是按值传递。

#include <functional>
#include <iostream>
#include <memory>

template <class WorkerType> class Delegate {
public:
  template <typename... Args>
  using WrkFunc = void (WorkerType::*)(Args... args);

  explicit Delegate(WorkerType &wrk) : m_worker(&wrk) {}

  template <typename... Args>
  void workerDo(WrkFunc<Args...> func, Args &&... args) {
    auto fn = std::bind(func, m_worker.get(), std::forward<Args>(args)...);
    fn();
  }

private:
  std::shared_ptr<WorkerType> m_worker;
};

class SomeWorker {
public:
  SomeWorker() = default;

  void doSomething(int &a) {
    a = 1000;
    std::cout << "2# address: " << &a << ", value: " << a << std::endl;
  }
};

int main() {
  SomeWorker wrk;
  Delegate<SomeWorker> del(wrk);
  int a = 0;
  std::cout << "1# address: " << &a << ", value: " << a << std::endl;
  del.workerDo(&SomeWorker::doSomething, a);
  std::cout << "3# address: " << &a << ", value: " << a << std::endl;
  return 0;
}

我期望的结果是这样的：
1#地址：0x7fffc1dc621c，值：0
2#地址：0x7fffc1dc621c，值：1000
3#地址：0x7fffc1dc621c，值：1000

但实际结果是：
1#地址：0x7fffc1dc621c，值：0
2#地址：0x7fffc1dc61d0，值：1000
3#地址：0x7fffc1dc621c，值：0

Answer 1

首先，您的 Delegate class 的构造函数完全损坏。这是 std::shared_ptr 的错误用法。你应该像下面这样修复：

// define
explicit Delegate(std::shared_ptr<WorkerType> wrk) : m_worker(std::move(wrk)) {}
//call
Delegate<SomeWorker> del(std::make_shared<SomeWorker>());

要将对象左值引用传递给 std::bind，您必须使用 std::ref.

How to bind function to an object by reference?

当您将 std::ref 结果传递给 workerDo 时，WrkFunc 会干扰调用。

因此，您需要使用 std::is_invocable_r_v

重写类型检查

#include <functional>
#include <iostream>
#include <memory>
#include <type_traits>
template <class WorkerType> class Delegate {
public:

  explicit Delegate(std::shared_ptr<WorkerType> wrk) : m_worker(std::move(wrk)) {}

  template <typename Func, typename ...Args, std::enable_if_t<std::is_invocable_r_v<void, Func, WorkerType, Args...>, std::nullptr_t> = nullptr>
  void workerDo(Func func, Args && ...args) {
    auto fn = std::bind(func, m_worker.get(), std::forward<Args>(args)...);
    fn();
  }

private:
  std::shared_ptr<WorkerType> m_worker;
};

class SomeWorker {
public:
  SomeWorker() = default;

  void doSomething(int &a) {
    a = 1000;
    std::cout << "2# address: " << &a << ", value: " << a << std::endl;
  }
};

int main() {
  Delegate<SomeWorker> del(std::make_shared<SomeWorker>());
  int a = 0;
  std::cout << "1# address: " << &a << ", value: " << a << std::endl;
  del.workerDo(&SomeWorker::doSomething, std::ref(a));
  std::cout << "3# address: " << &a << ", value: " << a << std::endl;
  return 0;
}

https://wandbox.org/permlink/fnBThXw5Uh72JeGQ

is there any method to avoid using std::ref everywhere call the workerDo ?

使用下面的包装器函数将解决。

template <class T, class U, std::enable_if_t<
    (std::is_lvalue_reference_v<T> ? std::is_lvalue_reference_v<U> : true) &&
    std::is_convertible_v<std::remove_reference_t<U>*, std::remove_reference_t<T>*>,
    std::nullptr_t
> = nullptr>
inline decltype(auto) forward_or_construct_reference_wrapper(U&& u)
{
    if constexpr(std::is_lvalue_reference_v<T>) {
        return std::reference_wrapper{std::forward<T>(u)};
    }
    else {
        return static_cast<T&&>(u);
    }
}

https://wandbox.org/permlink/wli9Dh9vXSjzBWMA

为什么通过通用引用运算符 (&&) 将变量引用传递给可变参数模板函数失败？

why pass reference of a varaible to a varadic template function by universal reference operator (&&) failed?

c++

function

variadic-templates

c++11