Question

我正在探索使用std::function和std::bind。我看到你可以绑定一个成员函数，例如：

class A{
    int c_ = 10;
public:
    int add(int a, int b){
        return a + b + c_;
    }
};
int main(){
    A* p_a = new A;
    std::function<int()> f = std::bind(&A::add, p_a, 1, 1);
    printf("%i\n", f()); // yields "12" (1 + 1 + 10)
    delete p_a;
    printf("%i\n", f()); // yields derpy numbers, no errors thrown.
}

有没有办法检测p_a是否已被删除？

我这样做的解决方案是拥有一个包含该函数的包装类，并为该对象提供weak_ptr。我只是想知道是否有更优雅的方法来做到这一点。

Answer 1

std::bind可以接受智能指针，因此您只需将std::shared_ptr<A>传递给它。

std::shared_ptr<A> p_a(new A);
std::function<int()> f = std::bind(&A::add, p_a, 1, 1);

注意，仿函数将拥有该对象：只要仿函数存在，对象就会存在。如果您不想要这样的行为，那么使用weak_ptr包装器的解决方案很不错。

Answer 2

struct A{
  int c_ = 10;
  int add(int a, int b){
    return a + b + c_;
  }
};
template<class T>
std::weak_ptr<T> weak( std::shared_ptr<T> const& sp ) { return {sp}; }

int main(){
  auto p_a = std::make_shared<A>();
  std::function<int()> f = [w_a = weak(p_a)]() {
    if (auto p_a = w_a.lock())
      return p_a->add(1,1);
    throw w_a;
  }
  printf("%i\n", f()); // yields "12" (1 + 1 + 10)
  p_a.reset();
  try {
    printf("%i\n", f()); // yields derpy numbers, no errors thrown.
  } catch( std::weak_ptr<A> wp ) {
    printf("object deleted\n");
  }
}

live example

一般来说，在C ++中，你不会为不使用的东西买单。

跟踪对象的生命周期需要付出代价。如果要跟踪对象的生命周期，可以使用shared_ptr或weak_ptr分配给（免费商店）对象，或使用weak_ptr到shared_ptr （唯一）由对象拥有，以表明其生命周期结束。

以上是使用C ++ 14 lambdas将对象的共享指针捕获为弱ptr的实现，并且如果已删除则给出已定义的行为（抛出所述弱指针的副本）。

生命周期令牌如下：

using lifetime_token = std::weak_ptr<void>;
struct has_lifetime {
  has_lifetime():token(std::make_shared<char>()) {}
  has_lifetime(has_lifetime const&o):has_lifetime() {} // not default
  lifetime_token get_lifetime() const {
    return token;
  }
private:
  std::shared_ptr<void> token;
};

继承自has_lifetime会给你一个get_lifetime()成员，只要你存在就会存在（它被析构函数破坏，不再是.lock() d）。

如果您无法修改原始类的所有权语义，那么这是一个更容易遵循的模式。只需.lock()对象的lifetime_token来确定它是否还活着。

是否可以检测绑定成员函数引用的对象是否被删除或销毁

2 个答案: