为成员模板函数创建概念以与 c++ 中的 boost::any 一起使用

Question

我正在尝试创建一个与 boost::any 一起使用的概念。这个概念应该说 一个类有一个带有签名void templateFunction(T t)的成员函数。我已经让它编译和工作正常，但一次只能用于一种类型。我想做的事是不可能的吗？

#include <iostream>

#include <boost/type_erasure/any.hpp>
#include <boost/type_erasure/any_cast.hpp>
#include <boost/type_erasure/builtin.hpp>
#include <boost/type_erasure/operators.hpp>
#include <boost/type_erasure/member.hpp>
#include <boost/type_erasure/free.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/any.hpp>

using namespace std;
namespace mpl = boost::mpl;
using namespace boost::type_erasure;

class Foo
{
    public:

        template <class T>
        void templateFunction(T t)
        {
            cout << t << endl;
        }
};

template<class C, class T>
struct has_template_function
{
    static void apply(C& cont, const T& arg) { cont.templateFunction(arg); }
};

namespace boost
{
    namespace type_erasure
    {
        template<class C, class T, class Base>
        struct concept_interface<has_template_function<C, T>, Base, C> : Base
        {
            void templateFunction(typename as_param<Base, const T&>::type arg)
            { call(has_template_function<C, T>(), *this, arg); }
        };
    }
}

int main()
{
    any<has_template_function<_self, int>, _self&> c = Foo();
    c.templateFunction(5);

    //Compile error: cannot convert parameter 1 from 'const char [6]' to 'const int &'
    //c.templateFunction("Hello");

    return 0;
}

Answer 1

这可以通过重载实现，并记录在官方Boost.TypeErasure documentation 中。

如 cmets 所述，需要注意的是：

您不能键入擦除模板并保持其多态性

因此，您必须在 boost::typeerasure::any 类型的要求中明确指定重载。

您需要按照文档中的说明修改您的概念接口，并将字符串重载添加到需求部分。

您的示例，经过修改以处理重载：

#include <iostream>

#include <boost/type_erasure/any.hpp>
#include <boost/type_erasure/any_cast.hpp>
#include <boost/type_erasure/builtin.hpp>
#include <boost/type_erasure/operators.hpp>
#include <boost/type_erasure/member.hpp>
#include <boost/type_erasure/free.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/any.hpp>
#include <string>
#include <utility>

using namespace std;
namespace mpl = boost::mpl;
using namespace boost::type_erasure;

struct FooStruct
{
    template <class T>
    void templateFunction(T t)
    {
        cout << t << endl;
    }
};

template<class T, class U>
struct has_template_function
{
    static void apply(T& t, const U& u) { t.templateFunction(u); }
};

namespace boost {
    namespace type_erasure {

        template<class T, class U, class Base, class Enable>
        struct concept_interface< ::has_template_function<T, U>, Base, T, Enable> : Base
        {
            typedef void _fun_defined;
            void templateFunction(typename as_param<Base, const U&>::type arg)
            {
                call(::has_template_function<T, U>(), *this, arg);
            }
        };

        template<class T, class U, class Base>
        struct concept_interface< ::has_template_function<T, U>, Base, T, typename Base::_fun_defined> : Base
        {
            using Base::templateFunction;
            void templateFunction(typename as_param<Base, const U&>::type arg)
            {
                call(::has_template_function<T, U>(), *this, arg);
            }
        };

    }
}

ostream& operator<<(ostream& os, const std::pair<int, string>& pair) {
    os << "(" << pair.first << ", " << pair.second << ")";
    return os;
}

int main()
{
    any<
        mpl::vector
        <
        has_template_function<_self, int>,
        has_template_function<_self, std::string>,
        has_template_function<_self, std::pair<int,std::string>>
        >
    , _self&> c = FooStruct();

    c.templateFunction(5);

    c.templateFunction("Hello");

    c.templateFunction(std::make_pair(5, "Hello"));

    return 0;
}