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:
~invoker_base()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:
functor_invoker(const F & f)19 explicit functor_invoker(const F& f) : f(f) { }
invoke(Args...args)20 R invoke(Args... args) { return f(args...); }
clone()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;
function()31 function() : invoker (0) { }
function(const function & other)32 function(const function& other) : invoker(0) {
33 if (other.invoker)
34 invoker = other.invoker->clone();
35 }
36
function(const F & f)37 template<typename F> function(const F& f) : invoker(0) {
38 invoker = new functor_invoker<F, R, Args...>(f);
39 }
40
~function()41 ~function() {
42 if (invoker)
43 delete invoker;
44 }
45
operator =(const function & other)46 function& operator=(const function& other) {
47 function(other).swap(*this);
48 return *this;
49 }
50
51 template<typename F>
operator =(const F & f)52 function& operator=(const F& f) {
53 function(f).swap(*this);
54 return *this;
55 }
56
swap(function & other)57 void swap(function& other) {
58 invoker_base<R, Args...>* tmp = invoker;
59 invoker = other.invoker;
60 other.invoker = tmp;
61 }
62
operator ()(Args...args) const63 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 {
operator ()add73 T operator()(T x, T y) { return x + y; }
74 };
75
add_ints(int x,int y)76 int add_ints(int x, int y) { return x + y; }
77
test_function()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 }
88