如何将已知签名的特定对象存储在C＆＃x2b;＆＃x2B;中的变量中？

Question

在某些对象实例上存储对特定签名的非静态成员函数的引用的推荐方法是什么？在调用代码不知道对象类（即没有铸件）的方式中，该功能是正确的签名。

例如，如果有两个不同的类带有相同void（int）签名的函数，那么

class Foo {
public:
  int myInt;
  
  void multMyInt(int multiplier) {
    myInt *= multiplier;
  }
};

class Bar {
public:
  bool isBig;
  
  void setMySize(int size) {
    isBig = size > 100;
  }
};

此代码应该是什么样的？

int main() {
  Foo* myFoo = new Foo();
  Bar* myBar = new Bar();

  int x = 10;

  callIntFunc(x, /* myFoo->multMyInt() */);
  callIntFunc(x, /* myBar->setMySize() */);
}

// Calls any function which matches void(int).
void callIntFunc(int inInt, /* function stored in some way */) {
  // call given function with inInt as the parameter
}

建议仅使用标准库做到这一点的建议方法是什么？

PS表示歉意，如果这是一个重复的问题。我已经搜索了任何想到的术语，找不到它。

Answer 1

由于您不仅要存储指向成员函数的指针，还要存储该函数应访问的对象，因此您需要一种将两者都存储在单一对象中的方法。

由于C ++具有LAMBDA函数，因此您可以将它们拿走并像从代码修改的以下示例中一样使用它们。

class Foo {
    public:
        int myInt;

        void multMyInt(int multiplier) {
            std::cout << "Calls multMyInt" << std::endl;
            myInt *= multiplier;
        }
};

class Bar {
    public:
        bool isBig;

        void setMySize(int size) {
            std::cout << "Calls setMySize" << std::endl;
            isBig = size > 100; 
        }
};

// Calls any function which matches void(int).
void callIntFunc(int inInt, auto& func )
{
    func(inInt);
}


int main() {
    Foo* myFoo = new Foo();
    Bar* myBar = new Bar();

    auto multMyInt = [myFoo](int parm){ myFoo->multMyInt(parm);};
    auto setMySize = [myBar](int parm){ myBar->setMySize(parm);};

    int x = 10;



    callIntFunc(x, multMyInt);
    callIntFunc(x, setMySize);
}

在C ++ 11之前，您必须使用std :: bind，但实际上不需要。

您还可以使用std :: function来使用auto，而是将inder -code使用：

// Calls any function which matches void(int).
void callIntFunc(int inInt, std::function<void(int)>& func )
{
    func(inInt);
}


int main() {
    Foo* myFoo = new Foo();
    Bar* myBar = new Bar();

    std::function<void(int)> multMyInt = [myFoo](int parm){ myFoo->multMyInt(parm);};
    std::function<void(int)> setMySize = [myBar](int parm){ myBar->setMySize(parm);};

    int x = 10;



    callIntFunc(x, multMyInt);
    callIntFunc(x, setMySize);
}

使用auto需要的模板版本为每个函数生成的其他程序内存类型A型新实例，但它很快。

std :: function版本需要更少的程序空间，但会导致稍微运行时开销。这取决于您喜欢的需求！

评论的更新：

在使用Lambdas的情况下，在您使用指示器或参考文献的所有其他情况下，没有什么特别的范围。但是您必须注意：

• 如果您通过引用捕获，则引用的对象必须活着，如果您调用函数 / lambda。
• 如果您捕获对象的副本，则将获得新的独立副本。因此，只要Lambda还活着，它是有效的，但是您可以参考副本而不是原始对象。

auto的类型是什么：

每个lambda都会产生一种新类型。该类型本身总是被实现隐藏和生成。这就是为什么您必须使用auto。

Answer 2

使用 std :: bind_front 。它与另一个答案中建议的自定义lambda相同，但语法较少。

auto func = std::bind_front(&Foo::multMyInt, myFoo);
func(42);

请注意，我们将类Pointer 作为第二个参数。如果我们取而代之的是值，则类实例将被复制到函子中。

这里auto扩展到某些未指定的类型，但是您可以用std :: function＆lt; void（int）＆gt;替换它。