Статические функции от boost.лямбда или буст.Феникс

я регулярно использую boost.лямбда (и Феникс) для определения лямбда-функций в C++. Мне очень нравится их полиморфное свойство, простота их представления и то, как они делают функциональное программирование на C++ намного проще. В некоторых случаях даже чище и читабельнее (если вы привыкли их читать) использовать их для определения небольших функций и именования их в статической области.

путь хранить эти функционалы который походит обычные функции большинство из них, чтобы захватить их в boost::function

const boost::function<double(double,double)> add = _1+_2;

но проблема заключается в неэффективности выполнения этого. Хотя add функция здесь не имеет состояния, возвращаемый лямбда-тип не пуст и его sizeof больше 1 (так boost::function по умолчанию ctor и копировать ctor будет включать new). Я действительно сомневаюсь, что есть механизм со стороны компилятора или boost для обнаружения этой безгражданства и генерации кода, который эквивалентен использование:

double (* const add)(double,double) = _1+_2; //not valid right now

можно, конечно, использовать c++11 auto, но тогда переменная не может быть передана без шаблонов контекстов. Я, наконец, удалось сделать почти то, что я хочу, используя следующий подход:

#include <boost/lambda/lambda.hpp>
using namespace boost::lambda;

#include <boost/type_traits.hpp>
#include <boost/utility/result_of.hpp>
using namespace boost;


template <class T>
struct static_lambda {

    static const T* const t;

    // Define a static function that calls the functional t
    template <class arg1type, class arg2type>
    static typename result_of<T(arg1type,arg2type)>::type 
        apply(arg1type arg1,arg2type arg2){
        return (*t)(arg1,arg2); 
    }

    // The conversion operator
    template<class func_type>
    operator func_type*() {
       typedef typename function_traits<func_type>::arg1_type arg1type;
       typedef typename function_traits<func_type>::arg2_type arg2type;
       return &static_lambda<T>::apply<arg1type,arg2type>;
    }
};

template <class T>
const T* const static_lambda<T>::t = 0;

template <class T>
static_lambda<T> make_static(T t) {return static_lambda<T>();}

#include <iostream>
#include <cstdio>


int main() {
    int c=5;
    int (*add) (int,int) = make_static(_1+_2);
    // We can even define arrays with the following syntax
    double (*const func_array[])(double,double) = {make_static(_1+_2),make_static(_1*_2*ref(c))};
    std::cout<<func_array[0](10,15)<<"n";
    std::fflush(stdout);
    std::cout<<func_array[1](10,15); // should cause segmentation fault since func_array[1] has state
}

скомпилировано с gcc 4.6.1 выход из этой программы (независимо от уровня оптимизации):

25
Segmentation fault

как и ожидалось. Здесь я сохраняю статический указатель на тип лямбда-выражения (как можно более const для оптимизации цели) и инициализация его в NULL. Таким образом, если вы попытаетесь "статизировать" лямбда-выражение с состоянием, вы обязательно получите ошибку времени выполнения. И если вы staticify подлинно без гражданства, лямбда, все работает.

на вопрос(ы):

1. метод кажется немного грязным, можете ли вы подумать о каких-либо обстоятельствах или предположении компилятора, которые сделают это неправильным (ожидаемое поведение: отлично работает, если лямбда без гражданства, segfault иначе.)

2. можете ли вы подумать о том, что попытка этого приведет к ошибке компилятора вместо segfault, когда лямбда-выражение имеет состояние?

редактировать после ответа Эрика ниблера:

#include <boost/phoenix.hpp>
using namespace boost::phoenix;
using namespace boost::phoenix::arg_names;

#include <boost/type_traits.hpp>
#include <boost/utility/result_of.hpp>
using boost::function_traits;

template <class T>
struct static_lambda {
    static const T t;

    // A static function that simply applies t
    template <class arg1type, class arg2type>
    static typename boost::result_of<T(arg1type,arg2type)>::type 
    apply(arg1type arg1,arg2type arg2){
    return t(arg1,arg2); 
    }

    // Conversion to a function pointer
    template<class func_type>
    operator func_type*() {
    typedef typename function_traits<func_type>::arg1_type arg1type;
        typedef typename function_traits<func_type>::arg2_type arg2type;
        return &static_lambda<T>::apply<arg1type,arg2type>;
    }
};

template <class T>
const T static_lambda<T>::t; // Default initialize the functional

template <class T>
static_lambda<T> make_static(T t) {return static_lambda<T>();}

#include <iostream>
#include <cstdio>


int main() {
    int (*add) (int,int) = make_static(_1+_2);

    std::cout<<add(10,15)<<"n";

    int c=5;

    // int (*add_with_ref) (int,int) = make_static(_1+_2+ref(c)); causes compiler error as desired
}