c++；11 lambda函数对象成员 我正在编写一些抽象类的C++库，用于一些科学计算。在其中一个类中，我使用一个函数对象，这样我就可以在数值算法中将它作为参数传递。我必须这样做，因为通常计算需要额外的参数，而我不能在数值算法中传递这些参数。我使用私有类（嵌套类）成功地实现了代码，用于构建函数对象。我现在尝试使用lambdas重写这个类来创建函数对象，但我不确定如何限制对lambdas中特定成员变量的访问

下面我有一个简单的程序来说明我所面临的问题

#include <iostream>
#include <functional>
using namespace std;

class A
{
public:
    A(int inI, int inJ) : _i(inI), _j(inJ)
    {
        create_functor();
    }

    A(const A& rtSide) : _i(rtSide._i),_j(rtSide._j)
    {
        create_functor();
    }

    A(A&& rtSide) : _i(rtSide._i), _j(rtSide._j)
    {
        rtSide.f = nullptr;
        create_functor();
    }

    A& operator=(A&& rtSide)
    {

        _i = rtSide._i;
        _j = rtSide._j;
        create_functor();

        rtSide.f = nullptr;

        return *this;
    }

    A& operator=(A& rtSide)
    {
        if (this == &rtSide)
            return *this;

        _i = rtSide._i;
        _j = rtSide._j;
        create_functor();

        rtSide.f = nullptr;

        return *this;
    }

    ~A() {}

    void reset_i(const int& newI) { _i = newI; }

    function<double(const double&)> f;

private:
    void create_functor()
    {
        f = [this](const double& inX) -> double {return inX * static_cast<double>(_i); };
    }

    int _i;
    int _j;
};

int main()
{

    A _A1(2,0);
    A _A2(1,0);

    _A2 = _A1;

    cout << _A2.f(2) << endl;

    _A2.reset_i(4);

    cout << _A2.f(2) << endl;

    return 0;
}

#包括
#包括
使用名称空间std；
甲级
{
公众：
A（inI，inJ）：\u i（inI），\u j（inJ）
{
创建函数（）；
}
A（常数A和rtSide）：\U i（rtSide.\U i），\U j（rtSide.\U j）
{
创建函数（）；
}
A（A和&rtSide）：\u i（rtSide.\u i），\u j（rtSide.\u j）
{
rtSide.f=nullptr；
创建函数（）；
}
A&运算符=（A&&rtSide）
{
_i=rtSide.\u i；
_j=rtSide._j；
创建函数（）；
rtSide.f=nullptr；
归还*这个；
}
A运算符=（A和rtSide）
{
if（this==&rtSide）
归还*这个；
_i=rtSide.\u i；
_j=rtSide._j；
创建函数（）；
rtSide.f=nullptr；
归还*这个；
}
~A（）{}
void reset_i（const int&newI）{u i=newI；}
函数f；
私人：
void create_函子（）
{
f=[this]（constdouble&inX）->double{returninx*static_cast（_i）；}；
}
int_i；
国际法院；
};
int main（）
{
A_A1（2,0）；
A_A2（1,0）；
_A2=_A1；
cout在中，您可以按值使用和捕获包装器：

std::reference_wrapper<decltype(_i)> r = _i;
f = [r](const double& inX) -> double {return inX * static_cast<double>(r.get()); };

std:：reference\u wrapper r=\u i；
f=[r]（constdouble&inX）->double{returninx*static_cast（r.get（））；}；

或其较短的等价物：

auto r = std::ref(_i);
f = [r](const double& inX) -> double {return inX * static_cast<double>(r.get()); };

autor=std:：ref（_i）；
f=[r]（constdouble&inX）->double{returninx*static_cast（r.get（））；}；


在中，可以使用通用的lambda捕获表达式：

f = [&_i = _i](const double& inX) -> double {return inX * static_cast<double>(_i); };

f=[&_i=_i]（constdouble&inX）->double{returninx*static_cast（_i）；}；

只是出于好奇：你为什么要这么做（限制访问）？也是出于好奇…；）