ラムダ式を継承

そういえば、ラムダ式って継承できるのかーと思いつつ書いてみた。

[ソース]

#include <utility>


template<typename ...Args>
struct overload;


template<typename T>
struct overload<T> : T{
    using T::operator();

    template<typename TT>
    overload(TT&& t) : T(std::forward<TT>(t)){}
};


template<typename T, typename U, typename ...Args>
struct overload<T, U, Args...>
    : T
    , overload<U, Args...>{

    using T::operator();
    using overload<U, Args...>::operator ();
    
    template<typename TT, typename... TArgs>
    overload(TT&& t, TArgs&&... args)
        : T(std::forward<TT>(t))
        , overload<U, Args...>(std::forward<TArgs>(args)...){}

};


template<typename... Funcs>
overload<typename std::decay<Funcs>::type...>
make_overload(Funcs&&... funcs){
    return { std::forward<Funcs>(funcs)... };
}


#include <iostream>
#include <string>

int
main(){
    int n = 3;
    auto f = make_overload(
        [](std::string const& str){
            return str + str;
        },
        [&](int m){
            return m + n;
        },
        [](int a, int b){
            return a + b;
        }
    );
    
    std::cout << f("homu") << std::endl;
    std::cout << f(5) << std::endl;
    std::cout << f(3, 8) << std::endl;

    return 0;
}

[出力]

homuhomu
8
11

面白い。

[コンパイラ]

• g++ (GCC) 4.8.0 20121104 (experimental)
• clang++ (LLVM) 3.2 20120514(trunk)