| 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 | } |
|---|
| 88 | |
|---|