std :: bind vs std :: shared_ptr

Не могу понять, как использовать shared_ptr, привязанный к функции класса. Ошибка возникает в строке USE, потому что компилятор не может преобразовать shared_ptr в A.

#include <functional>

class A {
    public:
        const bool check(void) const { return true; };
};

int _tmain(int argc, _TCHAR* argv[]) {
    const std::function<const bool(const A)> f_check = &A::check;
    auto a = std::make_shared<const A>();
    auto f_check_a = std::bind(f_check, a); // line BIND
    auto res = f_check_a(); // line USE - ERROR!!!

    return 0;
}

Я могу заменить строку BIND на доступ к реальному значению смарт-указателя:

int _tmain(int argc, _TCHAR* argv[]) {
    auto f_check = &A::check;
    auto a = std::make_shared<const A>();
    auto f_check_a = std::bind(f_check, *a.get()); // line BIND
    auto res = f_check_a(); // line USE - NO ERRORS

    return 0;
}

Теперь код скомпилирован и, возможно, он будет работать. Но я хотел бы знать - приемлемый ли способ использовать исходную ценность из умного указателя? Могу ли я каким-то образом использовать shared_ptr вместо необработанного значения?

UPD2: Похоже, мой коллега нашел приятное обходное решение:

class A {
    public:
        const bool check(void) const { return true; };
};

using p_func = const bool(A::*)() const;

int _tmain(int argc, _TCHAR* argv[]) {
    auto a = std::make_shared<const A>();
    p_func b = &A::check;
    auto f_check_a = std::bind(b, a);
    auto res = f_check_a();
}

Теперь я могу отправить b как аргумент и привязать к shared_ptr.

UPD: Я не могу использовать лямбда в своей реальной задаче. Вот еще код из реального проекта:

#include <functional>
#include <algorithm>

class Block {
    public:
        const bool check1(void) const { return false; };
        const bool check2(void) const { return false; };
        const bool check3(void) const { return false; };
};

using block_t = std::shared_ptr<const Block>;

class Worker {
    private:
        std::vector<const block_t> _container;
    public:
        void processor(const std::function<const bool(const Block)> f_check) {
            block_t my_block = nullptr;
            auto lambda = [my_block, f_check](const block_t block) mutable {
                auto function_check = std::bind(f_check, *block.get());
                if (function_check()) {
                    my_block = block;
                    return true;
                }
                return false;
            };
            std::find_if(_container.begin(), _container.end(), lambda);
        }
};

void test(block_t block) {
    Worker worker;
    worker.processor(&Block::check1);
    worker.processor(&Block::check2);
    worker.processor(&Block::check3);
}

UPD3: исправлен код без разыменования интеллектуальных указателей:

#include <functional>
#include <algorithm>

class Block {
public:
    const bool check1(void) const { return false; };
    const bool check2(void) const { return false; };
    const bool check3(void) const { return false; };
};

using block_t = std::shared_ptr<const Block>;
using p_func = const bool(Block::*)() const;

class Worker {
private:
    std::vector<const block_t> _container;
public:
    void processor(p_func f_check) {
        block_t my_block = nullptr;
        auto lambda = [my_block, f_check](const block_t block) mutable {
            auto function_check = std::bind(f_check, block);
            if (function_check()) {
                my_block = block;
                return true;
            }
            return false;
        };
        std::find_if(_container.begin(), _container.end(), lambda);
    }
};

void test(block_t block) {
    Worker worker;
    worker.processor(&Block::check1);
    worker.processor(&Block::check2);
    worker.processor(&Block::check3);
}