c++ - 构造对象的构造函数参数访问成员字段

Question

我有以下具有成员函数指针的结构。我的问题是，有没有办法让我传递给它的 lambda 引用它自己的成员变量？即

struct Foo
{
   int aVar{1};
   int (*funcPtr)(int);
   
   Foo(int (*func)(int)) : funcPtr(func) {};
};

auto bar1 = Foo([](int a) {std::cout << a;}) // ok
auto bar2 = Foo([](int a) {std::cout << a + bar2.aVar;}) // Not ok but is there a way to access the member variable of the object currently being defined?

我可以实现这种效果吗？

我想在这里实现的是一个根据您传入的 lambda 自动生成对象的过程。例如:上面的 bar2 是一个可以返回任何内容及其存储值的对象。即我希望 bar2.funcPtr(5) == 5 + bar2.aVar 成为类的不变量。将来我可能需要另一个可以返回任何减去其存储值的对象，我只需要传递相应的 lambda 即可(如果 lambda 可以访问成员字段)，而无需定义新的类或方法。

Answer 1

lambda 必须具有签名 int(int) 但您的 lambda 具有签名 void(int) 所以这是第一个问题。

另一个是 lambda 必须捕获 bar2。您可以为此使用 std::function。

#include <iostream>
#include <functional>

struct Foo {
   int aVar{1};

   std::function<int(int)> funcPtr;
   
   Foo(std::function<int(int)> func) : funcPtr(func) {};

   int call(int x) { return funcPtr(x); }
};

int main() {
    Foo bar2([&](int a) { return a + bar2.aVar; });

    std::cout << bar2.call(2);   // prints 3
}

一个更实用的解决方案是不将 lambda 绑定(bind)到它最初为其创建的实例，而是让它以 Foo& 作为参数(而不是捕获它)。使用这种方法，移动它不会变得如此麻烦。

例子:

struct Foo {
   int aVar;

   int(*funcPtr)(Foo&, int); // takes a Foo& as an argument
   
   Foo(int x, int(*func)(Foo&, int)) : aVar(x), funcPtr(func) {};

   int call(int x) { return funcPtr(*this, x); }
};

int main() {
    Foo bar2(10, [](Foo& f, int a) { return a + f.aVar; });

    std::cout << (bar2.call(5) == bar2.aVar + 5) << '\n';    // true

    Foo bar3(20, [](Foo& f, int a) { return a * f.aVar; });

    std::cout << bar2.call(2) << '\n'; // 10 + 2 = 12
    std::cout << bar3.call(2) << '\n'; // 20 * 2 = 40

    std::swap(bar2, bar3);

    std::cout << bar2.call(2) << '\n'; // swapped, now 40
    std::cout << bar3.call(2) << '\n'; // swapped, now 12
}