多种模版类函数：使用模版方法，重载operator() 构造模版函数类

你的名字 2021-12-11 03:47 298阅读 0赞

#pragma once
    
    #include <functional>
    #include <type_traits>
    #include <memory>
    #include <iostream>
    namespace internal{
    
        template <class R, class... Args>
        class FunctionBase{
        public:
            virtual R operator()(Args... args){
                throw std::bad_function_call();
            }
    
            virtual ~FunctionBase()= default;
        };
    
        template <class Func, class R, class... Args>
        class Function: public FunctionBase<R, Args...>{
        public:
            template < class F=Func,
                    class = std::enable_if_t<
                            !std::is_same<std::remove_reference_t<F>,Function>::value
                    >
            >
            explicit Function(F&& f):func_(std::forward<F>(f)){
                std::cout << "使用 internal::Function 构造函数" << '\n';
            }
    
            R operator()(Args... args) override{
                return func_(std::forward<Args>(args)...);
            }
    
        private:
            Func func_;
        };
    
    } // end namespace internal
    void TestFunc(int & a ){
        a++;
    }
    
    int TestFuncInt(int &a ) {
        return 16;
    }
    
    
    typedef internal::Function<std::function<int(int&)>, int, int&> Function_type;
    
    // 其中第二项 class，在编译的时候进行检查
    template <class =int,
            class A,
            class  = std::enable_if_t<!std::is_same<std::remove_reference_t<A>,Function_type>::value>>
    void TemA(){
        std::cout << "this is a function of TemA" << std::endl;
    };
    
    template <class>
    class Function;
    
    struct newA{
        int m;
    };
    //template <class R>
    template <class R>
    class Function<R()>{
    public:
        R a;
    };
    
    template <>
    class Function<int>{
    public:
        void Print(){
            std::cout << "第二种模版this is a template function of Function<int>"  <<'\n';
        }
    };
    
    template <class R, class... Args>
    class Function<R(Args...)>{
    public:
        template <class F,  class  = std::enable_if_t<!std::is_same<std::remove_reference_t<F>,Function>::value>>
        Function(F && f):func_(std::make_shared<internal::Function<F, R, Args...>>(std::forward<F>(f))){
            //std::cout << " class >>forward f:" << f << '\n';
            std::cout << "class >> shared_ptr<Function> :" << func_.get() << '\n';
        }
    
        R operator()(Args... args){
            return (*func_)(args...);
        }
    
        //使用智能指针，这样可以指到子类的类型
        std::shared_ptr<internal::FunctionBase<R,Args...> >func_;
    };
    
    int main(int argc, char**argv){
        //func ; //= TestFunc;
        // 其中定义Function, 返回类型，
        internal::Function<std::function<void(int&)>, void, int&> func1(TestFunc);
        int a = 1;
        func1(a);
        std::cout << "the result a:" << a << std::endl;
    
        internal::Function<std::function<int(int&)>, int, int&> func2(TestFuncInt);
        std::cout << "testFuncInt>>>:" << func2(a) << std::endl;
        std::cout << "testFuncInt2>>>: " <<TestFuncInt(a) << '\n';
    
        // 其中第二项 class，在编译的时候进行检查
        TemA<int,int>();
    
        // 第一种模版
        Function<newA()> aa_;
        newA c;
        c.m =12;
        aa_.a = c;
    
        // 第二种模版
        Function<int> bb;
        bb.Print();
    
        // 第三种模版
        std::shared_ptr<std::function<int(int&)>> AF =  std::make_shared<std::function<int(int&)>>(TestFuncInt);
        Function<int(int&)> func_tem(std::forward<std::function<int(int&)>>(*AF)); //
        std::cout << "the function of func_item:" << '\n';
        std::cout << func_tem(a) << '\n';
    
        return 0;
    }

输出：  
使用 internal::Function 构造函数  
the result a:2  
使用 internal::Function 构造函数  
testFuncInt>>>:16  
testFuncInt2>>>: 16  
this is a function of TemA  
第二种模版this is a template function of Function  
使用 internal::Function 构造函数  
class >> shared\_ptr :0x7fb6a4c02a90  
the function of func\_item:  
16

### 打印tuple 模版类型 ###

#include <iostream>
    #include <map>
    #include <tuple>
    // #include "types.h"
    namespace teaflow { 
    template <size_t ... Is>
    struct seq{ };
    
    template<std::size_t N, std::size_t... Is>
    struct gen_seq : gen_seq<N-1, N-1, Is...>{ };
    
    template<std::size_t... Is>
    struct gen_seq<0, Is...> : seq<Is...>{ };
    
    // 重载 ostream
    template <class Ta, class Tb>
    std::ostream& operator << (std::ostream& os, const std::pair<Ta, Tb>& p) { 
      return os << '(' << p.first << ',' << p.second << ')';
    }
    
    // 输出特定格式，例如Tuple格式
    template <typename Ch, class Tr, class Tuple, size_t ... Is>
    void print_tuple(std::basic_ostream<Ch, Tr>& os, Tuple const& t, seq<Is...>) { 
      using swallow = int[];
      // 使用 initilize int， 迭代 Is
      (void)swallow{ 0, (void(os << (Is == 0 ? "":",") << std::get<Is>(t)), 0) ...};
    }
    
    // format print typle
    template<class Ch, class Tr, class... Args>
    auto operator<<(std::basic_ostream<Ch, Tr>& os, std::tuple<Args...> const& t)
    -> std::basic_ostream<Ch, Tr>& { 
      os << "[";
      print_tuple(os, t, gen_seq<sizeof...(Args)>());
      return os << "]";
    }
    }
    
    using namespace teaflow;
    int main() { 
      std::tuple<std::string, int> a=std::make_tuple("a", 1);
      std::basic_ostream<char, std::char_traits<char>>& f2 = std::cout;
      teaflow::seq<0> seq;
      std::tuple<std::pair<char, char> > b  = std::make_tuple(std::make_pair('a', '1'));
    
      teaflow::print_tuple<char, std::char_traits<char>
          >(f2, b, seq);
    
      // 输出 tuple 类型 b
      f2 << b;
      return 0;
    }

输出：  
(a,1)\[(a,1)\]