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

77 阅读 0 评论 51 点赞

我是靠谱客的博主魁梧丝袜，最近开发中收集的这篇文章主要介绍多种模版类函数：使用模版方法，重载operator() 构造模版函数类，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

#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;
}