C++ 将指针绑定到C++；

他们的目的是什么？
我从来没有用过它们做任何事情，我看不出自己需要用它们。
我是错过了一些关于它们的东西，还是它们几乎毫无用处？

---

编辑：我对它们了解不多，因此可能需要对它们进行描述…

将指针绑定到函数在各种情况下都非常有用。基本上，它允许您将函数作为变量引用，这允许您在运行时选择要调用的函数

其中一个用途是“回调”。假设我想让一些后台进程工作一段时间，并让我们知道它何时完成（以便我们可以更新GUI或其他东西）。但有时，我们可能希望这个后台进程调用一个方法，有时，我们希望它调用另一个方法。我们不需要编写这个后台进程的两个版本，而是可以编写它，以便后台进程接收到一个指向我们希望它“回调”的函数的指针。然后，当该过程完成时，它将调用它最初给定的任何函数

---

基本上，它只是让您在决定调用哪个方法时有更大的灵活性。这样，它与多态性非常相似。事实上，在幕后，我相信C++可以使用函数的指针来促进多态性（通过将指针的不同表存储到每个类的函数）

< P>如果我正确地理解了你的问题。为什么不呢

struct test
{
    test* operator->() 
    { 
        std::cout << "test::operator->";
        return this; 
    }
};

test tt;
boost::bind( &test::operator ->, _1 )( tt );

struct测试
{
测试*运算符->（）
{ 
标准：cout，_1）（tt）；

PMF（指向成员函数的指针）与普通（静态）函数指针类似，只是因为非静态成员函数需要指定

this

对象，所以PMF调用语法（

*

或

->*

）允许指定

this

对象（在左侧）

下面是一个正在使用的PMF示例（请注意使用的带有

*

运算符的“魔术”行：

（lhs.*.opit->second）（…）

，以及创建PMF的语法，

&class:：func

）：

#包括
#包括
#包括
#包括
#包括
#包括
名称空间{
使用std:：cin；使用std:：complex；使用std:：cout；
使用std:：无效的_参数；使用std:：map；使用std:：stack；
使用std:：string；使用std:：underflow\u error；
typedef复合物xd；
typedef complexd&（complexd:：*complexd_pmf）（complexd const&）；
typedef-map-opmap；
模板
typename T:：参考顶部（T&st）{
if（st.empty（））
抛出下溢_错误（“空堆栈”）；
返回圣托普（）；
}
}
int
main（）
{
opmap const ops{{'+'，complexd:：operator+=}，
{'-'，complexd:：operator-=}，
{'*'，complexd:：operator*=}，
{'/'，&complexd:：operator/=}；
char op；
复杂val；
斯塔克街；
而（cin>>op）{
常量迭代器opit（ops.find（op））；
if（opit！=ops.end（））{
综合右岸（顶部（st））；
圣普（）；
//例如->*语法：
complexd&lhs（top（st））；//complexd*lhs（&top（st））；
（左座。*右座->第二座）（右座）；/（左座->*右座->第二座）（右座）；
cout是您正在寻找的？不，更具体地说，是。*和->*运算符。我怀疑不是，我想他说的是指向成员运算符（例如运算符+）的指针@nevets：它与我正在寻找的相关，但是这个问题没有更多的基本信息，我需要将它与我正在问的问题联系起来。我还更新了我的答案来描述什么是PMF。希望这能让你更容易地与普通的jane函数指针进行比较。：-）代码没有错误检查，但是无论如何，我希望你能理解这个想法。：-DYeah，这很有意义。谢谢你的例子。更新了我的版本，实际上添加了一些错误检查，因为在空堆栈上获取segfaults确实让我感到困扰。：-）我的问题更多的是，这些运算符是什么，而不是使用这些运算符的替代方案是什么。
#include <complex>
#include <iostream>
#include <map>
#include <stack>
#include <stdexcept>
#include <string>

namespace {
    using std::cin; using std::complex; using std::cout;
    using std::invalid_argument; using std::map; using std::stack;
    using std::string; using std::underflow_error;

    typedef complex<double> complexd;
    typedef complexd& (complexd::*complexd_pmf)(complexd const&);
    typedef map<char, complexd_pmf> opmap;

    template <typename T>
    typename T::reference top(T& st) {
        if (st.empty())
            throw underflow_error("Empty stack");
        return st.top();
    }
}

int
main()
{
    opmap const ops{{'+', &complexd::operator+=},
                    {'-', &complexd::operator-=},
                    {'*', &complexd::operator*=},
                    {'/', &complexd::operator/=}};

    char op;
    complexd val;
    stack<complexd> st;

    while (cin >> op) {
        opmap::const_iterator opit(ops.find(op));
        if (opit != ops.end()) {
            complexd rhs(top(st));
            st.pop();
                                        // For example of ->* syntax:
            complexd& lhs(top(st));     // complexd* lhs(&top(st));
            (lhs.*opit->second)(rhs);   // (lhs->*opit->second)(rhs);
            cout << lhs << '\n';        // cout << *lhs << '\n';
        } else if (cin.unget() && cin >> val) {
            st.push(val);
        } else {
            throw invalid_argument(string("Unknown operator ") += op);
        }
    }
}