Вызов const метод std::function

@rikimaru2013 · Регистрация: 30.11.2013

Author24 — интернет-сервис помощи студентам

Добрый день,

C++

#include <functional>
#include <string>
#include <iostream>
using namespace std;
 
class Foo
{
public:
    std::string getValue(double, int, std::string) const
    {
        cout << "const" << endl;
        return "";
    }
    std::string getValue(double, int, std::string)
    {
        cout << "non-const" << endl;
        return "";
    }
};
 
 
 
int main()
{
    Foo foo;
 
    std::function<std::string(double, int, std::string)> 
        callback = std::bind(&Foo::getValue, &foo, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
 
 
    callback(3.15, 1, "");
 
}

Error:

cannot determine which instance of overloaded function "Foo::getValue" is intended

Как забиндить метод учитывая, что если будет const Foo foo вызывался другой. Не уж то будете советывать транзитный метод?

@DrOffset · 01.12.2015, 13:54

Сообщение от rikimaru2013

Не уж то будете советывать транзитный метод?

Можно просто static_cast`ом привести к указателю на нужную функцию.
А можно и что-то поинтереснее придумать:

Кликните здесь для просмотра всего текста

C++

#include <functional>
#include <string>
#include <iostream>
using namespace std;
 
class Foo
{
public:
    std::string getValue(double, int, std::string) const
    {
        cout << "const" << endl;
        return "";
    }
    std::string getValue(double, int, std::string)
    {
        cout << "non-const" << endl;
        return "";
    }
};
 
template <typename C, typename F>
struct rebuild_function;
 
template <typename C, typename R, typename ...Args>
struct rebuild_function<C, R(Args...)>
{
    using type = R (C::*)(Args...);
};
template <typename C, typename R, typename ...Args>
struct rebuild_function<C, R(Args...) const>
{
    using type = R (C::*)(Args...) const;
};
 
template <typename C, typename F>
auto memfun_cast(typename rebuild_function<C, F>::type f) -> decltype(f)
{
    return f;
}
 
int main()
{
    Foo foo;
 
    using get_value_t = std::string(double, int, std::string);
    using get_value_const_t = std::string(double, int, std::string) const;
 
    std::function<get_value_t> callback1
        = std::bind(memfun_cast<Foo, get_value_const_t>(&Foo::getValue)
                  , &foo, std::placeholders::_1
                        , std::placeholders::_2
                        , std::placeholders::_3);
 
    callback1(3.15, 1, "");
 
    std::function<get_value_t> callback2
        = std::bind(memfun_cast<Foo, get_value_t>(&Foo::getValue)
                  , &foo, std::placeholders::_1
                        , std::placeholders::_2
                        , std::placeholders::_3);
 
    callback2(3.15, 1, "");
}

http://rextester.com/WQOXQZ76254

@Voivoid · 01.12.2015, 14:59

Сообщение от DrOffset

А можно и что-то поинтереснее придумать:

Я себе для подобных случаев такие вот вспомогательные штуки написал:

C++

template <typename Sig, typename Class>
constexpr Sig Class::* select_overload( Sig( Class::*fn ) ) noexcept
{
  return fn;
}
 
template <typename Sig>
constexpr Sig* select_overload( Sig( *fn ) ) noexcept
{
  return fn;
}

Юзать как-то так:

C++

1	std::bind(select_overload<std::string(double,int,std::string)const>(&Foo::getValue), &foo, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);

@rikimaru2013 · 01.12.2015, 15:33 **[ТС]**

Кликните здесь для просмотра всего текста

C++

#include <string>
#include <iostream>
#include <functional>
using namespace std;
 
// ---------------------------------------------- CALLBACK -----------------------------------------------------------------
class Foo
{
public:
    int f(float, string) const
    {
        return 77;
    }
    int f(float, string)
    {
        return 32;
    }
};
 
 
 
// ---------------------------------------------- AUTO DEDUCTION PROCESS ----------------------------------------------------
template<class T> struct help;
 
template<class ClassType, class ReturnType, class... Args>
struct help<ReturnType(ClassType::*)(Args...) const>
{
    typedef std::function<ReturnType(Args...)>
        type;
 
    template<class ClassEncapsulatorOfCallback, ClassEncapsulatorOfCallback callbackMethod>         
    static type init(const ClassType& obj)
    {                                                                                               
 
        const auto lambda = [obj](Args... args) mutable {
            return (obj.*callbackMethod)(std::forward<Args>(args)...);
        };
        return lambda;
    }
};
template<class ClassType, class ReturnType, class... Args>
struct help<ReturnType(ClassType::*)(Args...)>
{
    typedef std::function<ReturnType(Args...)>
        type;
 
    template<class ClassEncapsulatorOfCallback, ClassEncapsulatorOfCallback callbackMethod>
    static type init(ClassType& obj)
    {
 
        const auto lambda = [obj](Args... args) mutable {
            return (obj.*callbackMethod)(std::forward<Args>(args)...);
        };
        return lambda;
    }
};
 
template <typename C, typename F>
struct rebuild_function;
 
template <typename C, typename R, typename ...Args>
struct rebuild_function<C, R(Args...)>
{
    using type = R(C::*)(Args...);
};
template <typename C, typename R, typename ...Args>
struct rebuild_function<C, R(Args...) const>
{
    using type = R(C::*)(Args...) const;
};
template <typename C, typename F>
auto memfun_cast(typename rebuild_function<C, F>::type f) -> decltype(f)
{
    return f;
}
 
 
// ---------------------------------------------- EXAMPLE of USING ----------------------------------------------------------
class B
{
    using get_value_t                       = int(float, string);
    using get_value_const_t                 = int(float, string) const;
 
    using const_callback                    = decltype(memfun_cast<Foo, get_value_const_t>(&Foo::f));
    typedef help< const_callback >          helper_const;
    typedef helper_const::type              MyCallbackTypeConst;
 
    using non_const_callback                = decltype(memfun_cast<Foo, get_value_t>(&Foo::f));
    typedef help< non_const_callback >      helper_non_const;
    typedef helper_non_const::type          MyCallbackTypeNonConst;
    
    MyCallbackTypeConst                     m_callback;
    
public:
    
    B()
    {       
                                                        
    }
    void bind(const Foo* const obj)
    {
        m_callback = helper_const::init< const_callback, &Foo::f>(*obj);
 
        cout << m_callback(3.154F, "privet") << endl;
    }
    void bind(Foo* obj)
    {
        m_callback = helper_non_const::init <non_const_callback, &Foo::f>(*obj);
 
        cout << m_callback(3.154F, "privet") << endl;
    }
};
 
// ---------------------------------------------- MAIN ----------------------------------------------------------
int main()
{
 
    Foo* a1 = new Foo();
    const Foo* a2 = new Foo();
    B* b = new B();
 
 
    b->bind(a1);
    b->bind(a2);
    
}

Что-то у меня не получается автоопределить 81 и 82 строку.

@DrOffset · 01.12.2015, 16:31

Сообщение от rikimaru2013

Что-то у меня не получается автоопределить 81 и 82 строку.

Что значит не получается?

@rikimaru2013 · 01.12.2015, 16:45 **[ТС]**

Сообщение от DrOffset

Что значит не получается?

для автоопределения типа (более того модификатора const) надо написать промежуточный класс помощник, который через тот же &Foo::f не поймет какой метод const/не const ему прислали в качестве параметра шаблона. 81 и 82 помогли классу helper это понять - и еще один helper опять же потребует 81 и 82 строку .

@gromo · 01.12.2015, 17:29

Сообщение от DrOffset

std::function<get_value_t>

Почему в обоих случаях (const/non-const) в std::function передается только get_value_t ? А если сделать std::function<get_value_const_t>(...) — то вообще ошибка компиляции

@DrOffset · 01.12.2015, 18:14

Сообщение от rikimaru2013

для автоопределения

Если я правильно тебя понял, то тут слишком умного "автоопределения" быть не может, т.к. только программист в состоянии разрешить неоднозначность между перегруженными функциями. Поэтому тип функции должен быть указан явно (либо выведен явно из другого контекста). Но "само в себе" оно работать не будет.

Сообщение от gromo

Почему в обоих случаях (const/non-const) в std::function передается только get_value_t ?

Потому что std::function не учитывает этот const в параметре (у него даже специализации такой нет). Возможность вызова cv- или не cv-функции класса он определяет по cv объекта, который биндится.

@rikimaru2013 · 01.12.2015, 18:24 **[ТС]**

Сообщение от DrOffset

тут слишком умного "автоопределения" быть не может

Так я вот и рыл в эту сторону скрыть реализацию автоопределения, и предоставить прозрачный лёгкий способ использования. Но блин камен на камне как начал копать ))))

@DrOffset · 01.12.2015, 18:32

Сообщение от rikimaru2013

лёгкий способ использования

Легче, чем написал Voivoid, не получится

@DrOffset 18840 / 9839 / 2408 Регистрация: 30.01.2014 Сообщений: 17,280
	01.12.2015, 18:32	10
	Сообщение от rikimaru2013 лёгкий способ использования Легче, чем написал Voivoid, не получится 0

Вызов const метод std::function

Решение

Решение

@DrOffset 18840 / 9839 / 2408 Регистрация: 30.01.2014 Сообщений: 17,280
	01.12.2015, 16:31	5
	Сообщение от rikimaru2013 Что-то у меня не получается автоопределить 81 и 82 строку. Что значит не получается? 0

@rikimaru2013 2549 / 1208 / 358 Регистрация: 30.11.2013 Сообщений: 3,826
	01.12.2015, 16:45 [ТС]	6
	Сообщение от DrOffset Что значит не получается? для автоопределения типа (более того модификатора const) надо написать промежуточный класс помощник, который через тот же `&Foo::f` не поймет какой метод const/не const ему прислали в качестве параметра шаблона. 81 и 82 помогли классу helper это понять - и еще один helper опять же потребует 81 и 82 строку . 0

@gromo 383 / 281 / 31 Регистрация: 04.09.2009 Сообщений: 1,225
	01.12.2015, 17:29	7
	Сообщение от DrOffset std::function<get_value_t> Почему в обоих случаях (const/non-const) в `std::function` передается только `get_value_t` ? А если сделать `std::function<get_value_const_t>(...)` — то вообще ошибка компиляции 0

@DrOffset 18840 / 9839 / 2408 Регистрация: 30.01.2014 Сообщений: 17,280
	01.12.2015, 18:14	8
	Сообщение от rikimaru2013 для автоопределения Если я правильно тебя понял, то тут слишком умного "автоопределения" быть не может, т.к. только программист в состоянии разрешить неоднозначность между перегруженными функциями. Поэтому тип функции должен быть указан явно (либо выведен явно из другого контекста). Но "само в себе" оно работать не будет. Сообщение от gromo Почему в обоих случаях (const/non-const) в std::function передается только get_value_t ? Потому что std::function не учитывает этот const в параметре (у него даже специализации такой нет). Возможность вызова cv- или не cv-функции класса он определяет по cv объекта, который биндится. 1

@rikimaru2013 2549 / 1208 / 358 Регистрация: 30.11.2013 Сообщений: 3,826
	01.12.2015, 18:24 [ТС]	9
	Сообщение от DrOffset тут слишком умного "автоопределения" быть не может Так я вот и рыл в эту сторону скрыть реализацию автоопределения, и предоставить прозрачный лёгкий способ использования. Но блин камен на камне как начал копать )))) 0