C++ 获取对const规范重载的成员函数的引用

下面是一个具有两个重载方法foo的类：

类对象{
公众：
Object（double-someVal）：val（someVal）{}
双getter（）常量{return val；}
double&getter（）{return val；}
私人：
双val；
};

因此，现在将对const实例调用

double Object:：getter（）const

函数

const对象实例（42）；
cout通过强制转换到特定的函数指针类型：

std::function<double(const Object&)> foo = static_cast<double(Object::*)() const>(&Object::getter);

std:：function foo=static\u cast（&Object:：getter）；
您可以使用typedef来消除所需函数的歧义：

#include <iostream>
#include <functional>

class Object {
public:
    Object (double someVal) : val(someVal) { }
    double getter () const { return val; }
    double& getter () { return val; }
private:
    double val;
};

typedef double (Object::*funtype)() const;

int main()
{
    const Object instance(42);
    std::function<double(const Object&)> foo = static_cast<funtype>(&Object::getter);
    std::cout << foo(instance) << std::endl;
}

#包括
#包括
类对象{
公众：
Object（double-someVal）：val（someVal）{}
双getter（）常量{return val；}
double&getter（）{return val；}
私人：
双val；
};
typedef double（对象：：*funtype）（）const；
int main（）
{
常量对象实例（42）；
std:：function foo=static\u cast（&Object:：getter）；
std:：cout只需使用lambda闭包：

Object o{0.0};
std::function<double()> f = [o](){ return o.getter(); };

对象o{0.0}；
函数f=[o]（）{return o.getter（）；}；

lambda调用常量版本的
getter（）
，因为默认情况下捕获的变量是
const
（否则必须使用
mutable
）

有几种方法可以选择所需的重载：

#include <iostream>
#include <functional>

class Object {
public:
    Object (double someVal) : val(someVal) { }
    double getter () const { return val; }
    double& getter () { return val; }
private:
    double val;
};

typedef double (Object::*funtype)() const;

int main()
{
    const Object instance(42);
    std::function<double(const Object&)> foo = static_cast<funtype>(&Object::getter);
    std::cout << foo(instance) << std::endl;
}

const对象实例（42）；
//使用static_cast选择重载
std:：function foo=static\u cast（&Object:：getter）；
//使用lambda选择重载
//sd:：函数类型参数可以从C++ 17中省略
/C++ 17以来的保证复制删除
std:：function bar=[]（常量对象和实例）{return instance.getter（）；}；
//使用std:：mem_fn
std:：function mfn=std:：mem_fn（&Object:：getter）；


然而，声明具有类似功能但因常量不同的方法的惯用方法实际上是声明两个不同的函数：
foo（）
和
cfoo（）
。想想
begin（）
和
cbegin（）
。后者返回一个常量迭代器。
又是一个例子，介绍了一些选项

// auto mem_fn = static_cast<double (Object::*)() const>(&Object::getter);
// or shorter:
double (Object::*mem_fn)() const = &Object::getter;

// store member function (without instance)
std::function<double(const Object&)> foo = mem_fn;
std::cout << foo(instance) << "\n";

// bind with instance
auto bound = std::bind(mem_fn, &instance);
std::cout << bound() << "\n";

// store member function (with instance)
std::function<double()> bar = bound;
std::cout << bar() << "\n";

// store member function (with instance), without the intermediate steps
std::function<double()> baz =
    std::bind(
        static_cast<double (Object::*)() const>(&Object::getter),
        instance
    );
std::cout << baz() << "\n";

//auto mem\u fn=static\u cast（&Object:：getter）；
//或更短：
double（Object:：*mem_fn）（）const=&Object:：getter；
//存储成员函数（无实例）
std:：function foo=mem_fn；
std:：cout-related/dupe:Yes。我尝试了两种变体。都失败了：1.函数foo=static\u-cast（&Object:：getter）；2.函数foo=static\u-cast（&Object:：getter）；哦，这很聪明。如果你对使用非常量版本感兴趣，
mutable
会去哪里？@Ruzhim:谢谢。
mutable
在参数后面，即
std:：function f=[o]（）mutable{return o.getter（）；}；
调用
getter（）
的非常量版本。
// auto mem_fn = static_cast<double (Object::*)() const>(&Object::getter);
// or shorter:
double (Object::*mem_fn)() const = &Object::getter;

// store member function (without instance)
std::function<double(const Object&)> foo = mem_fn;
std::cout << foo(instance) << "\n";

// bind with instance
auto bound = std::bind(mem_fn, &instance);
std::cout << bound() << "\n";

// store member function (with instance)
std::function<double()> bar = bound;
std::cout << bar() << "\n";

// store member function (with instance), without the intermediate steps
std::function<double()> baz =
    std::bind(
        static_cast<double (Object::*)() const>(&Object::getter),
        instance
    );
std::cout << baz() << "\n";