clang/test/CXX/temp/temp.decls/temp.variadic/example-function.cpp

   1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
   2 // expected-no-diagnostics
   3
   4 // Example function implementation from the variadic templates proposal,
   5 // ISO C++ committee document number N2080.
   6
   7 template<typename Signature> class function;
   8
   9 template<typename R, typename... Args> class invoker_base {
  10 public:
  11   virtual ~invoker_base() { }
  12   virtual R invoke(Args...) = 0;
  13   virtual invoker_base* clone() = 0;
  14 };
  15
  16 template<typename F, typename R, typename... Args>
  17 class functor_invoker : public invoker_base<R, Args...> {
  18 public:
  19   explicit functor_invoker(const F& f) : f(f) { }
  20   R invoke(Args... args) { return f(args...); }
  21   functor_invoker* clone() { return new functor_invoker(f); }
  22
  23 private:
  24   F f;
  25 };
  26
  27 template<typename R, typename... Args>
  28 class function<R (Args...)> {
  29 public:
  30   typedef R result_type;
  31   function() : invoker (0) { }
  32   function(const function& other) : invoker(0) {
  33     if (other.invoker)
  34       invoker = other.invoker->clone();
  35   }
  36
  37   template<typename F> function(const F& f) : invoker(0) {
  38     invoker = new functor_invoker<F, R, Args...>(f);
  39   }
  40
  41   ~function() {
  42     if (invoker)
  43       delete invoker;
  44   }
  45
  46   function& operator=(const function& other) {
  47     function(other).swap(*this);
  48     return *this;
  49   }
  50
  51   template<typename F>
  52   function& operator=(const F& f) {
  53     function(f).swap(*this);
  54     return *this;
  55   }
  56
  57   void swap(function& other) {
  58     invoker_base<R, Args...>* tmp = invoker;
  59     invoker = other.invoker;
  60     other.invoker = tmp;
  61   }
  62
  63   result_type operator()(Args... args) const {
  64     return invoker->invoke(args...);
  65   }
  66
  67 private:
  68   invoker_base<R, Args...>* invoker;
  69 };
  70
  71 template<typename T>
  72 struct add {
  73   T operator()(T x, T y) { return x + y; }
  74 };
  75
  76 int add_ints(int x, int y) { return x + y; }
  77
  78 void test_function() {
  79   function<int(int, int)> f2a;
  80   function<int(int, int)> f2b = add<int>();
  81   function<int(int, int)> f2c = add<float>();
  82   function<int(int, int)> f2d(f2b);
  83   function<int(int, int)> f2e = &add_ints;
  84   f2c = f2d;
  85   f2d = &add_ints;
  86   f2c(1.0, 3);
  87 }