Saya baru mengenal C ++ 11. Saya menulis fungsi lambda rekursif berikut, tetapi tidak mengkompilasi.

sum.cpp

#include <iostream>
#include <functional>

auto term = [](int a)->int {
  return a*a;
};

auto next = [](int a)->int {
  return ++a;
};

auto sum = [term,next,&sum](int a, int b)mutable ->int {
  if(a>b)
    return 0;
  else
    return term(a) + sum(next(a),b);
};

int main(){
  std::cout<<sum(1,10)<<std::endl;
  return 0;
}

kesalahan kompilasi:

vimal @ linux-718q: ~ / Study / 09C ++ / c ++ 0x / lambda> g ++ -std = c ++ 0x sum.cpp

sum.cpp: Dalam fungsi lambda: sum.cpp: 18: 36: error: ' ((<lambda(int, int)>*)this)-><lambda(int, int)>::sum' tidak dapat digunakan sebagai fungsi

versi gcc

gcc versi 4.5.0 20091231 (percobaan) (GCC)

Tetapi jika saya mengubah deklarasi sum()seperti di bawah ini, itu berfungsi:

std::function<int(int,int)> sum = [term,next,&sum](int a, int b)->int {
   if(a>b)
     return 0;
   else
     return term(a) + sum(next(a),b);
};

Bisakah seseorang menjelaskan hal ini?

Pikirkan tentang perbedaan antara versi otomatis dan versi tipe yang ditentukan sepenuhnya. Kata kunci otomatis menyimpulkan jenisnya dari apa pun yang diinisialisasi, tetapi apa yang Anda inisialisasi perlu tahu apa jenisnya (dalam hal ini, penutupan lambda perlu mengetahui jenis yang ditangkapnya). Sesuatu dari masalah ayam dan telur.

Di sisi lain, tipe objek fungsi yang ditentukan sepenuhnya tidak perlu "tahu" apa pun tentang apa yang ditugaskan padanya, sehingga penutupan lambda juga dapat sepenuhnya diinformasikan tentang jenis yang ditangkapnya.

Pertimbangkan sedikit modifikasi kode ini dan mungkin lebih masuk akal:

std::function<int(int,int)> sum;
sum = [term,next,&sum](int a, int b)->int {
if(a>b)
    return 0;
else
    return term(a) + sum(next(a),b);
};

Jelas, ini tidak akan berfungsi dengan otomatis . Fungsi lambda rekursif bekerja dengan sangat baik (setidaknya mereka lakukan di MSVC, di mana saya memiliki pengalaman dengan mereka), hanya saja mereka tidak benar-benar kompatibel dengan inferensi tipe.

Caranya adalah memberi makan dalam implementasi lambda untuk dirinya sendiri sebagai parameter , bukan dengan menangkap.

const auto sum = [term,next](int a, int b) {
  auto sum_impl=[term,next](int a,int b,auto& sum_ref) mutable {
    if(a>b){
      return 0;
    }
    return term(a) + sum_ref(next(a),b,sum_ref);
  };
  return sum_impl(a,b,sum_impl);
};

Semua masalah dalam ilmu komputer dapat diselesaikan dengan tingkat tipuan lainnya . Saya pertama kali menemukan trik mudah ini di http://pedromelendez.com/blog/2015/07/16/recursive-lambdas-in-c14/

Ini tidak memerlukan C ++ 14 sementara pertanyaannya adalah pada C ++ 11, tapi mungkin menarik untuk sebagian besar.

Pergi melalui std::functionjuga dimungkinkan tetapi dapat menghasilkan kode lebih lambat. Tapi tidak selalu. Lihatlah jawaban untuk std :: function vs template

Ini bukan hanya kekhasan tentang C ++, itu langsung memetakan ke matematika kalkulus lambda. Dari Wikipedia :

Lambda calculus cannot express this as directly as some other notations:
all functions are anonymous in lambda calculus, so we can't refer to a
value which is yet to be defined, inside the lambda term defining that
same value. However, recursion can still be achieved by arranging for a
lambda expression to receive itself as its argument value

Dengan C ++ 14, sekarang cukup mudah untuk membuat lambda rekursif yang efisien tanpa harus mengeluarkan biaya tambahan std::function, hanya dalam beberapa baris kode (dengan suntingan kecil dari aslinya untuk mencegah pengguna mengambil salinan yang tidak disengaja). ):

template <class F>
struct y_combinator {
    F f; // the lambda will be stored here

    // a forwarding operator():
    template <class... Args>
    decltype(auto) operator()(Args&&... args) const {
        // we pass ourselves to f, then the arguments.
        // [edit: Barry] pass in std::ref(*this) instead of *this
        return f(std::ref(*this), std::forward<Args>(args)...);
    }
};

// helper function that deduces the type of the lambda:
template <class F>
y_combinator<std::decay_t<F>> make_y_combinator(F&& f) {
    return {std::forward<F>(f)};
}

yang dengannya sumupaya awal Anda menjadi:

auto sum = make_y_combinator([term,next](auto sum, int a, int b) {
  if (a>b) {
    return 0;
  }
  else {
    return term(a) + sum(next(a),b);
  }
});

Di C ++ 17, dengan CTAD, kita dapat menambahkan panduan deduksi:

template <class F> y_combinator(F) -> y_combinator<F>;

Yang meniadakan kebutuhan akan fungsi pembantu. Kita bisa y_combinator{[](auto self, ...){...}}langsung menulis .

Dalam C ++ 20, dengan CTAD untuk agregat, panduan deduksi tidak diperlukan.

Saya punya solusi lain, tetapi hanya bekerja dengan lambdas tanpa kewarganegaraan:

void f()
{
    static int (*self)(int) = [](int i)->int { return i>0 ? self(i-1)*i : 1; };
    std::cout<<self(10);
}

Trik di sini adalah lambda dapat mengakses variabel statis dan Anda dapat mengonversi yang stateless ke penunjuk fungsi.

Anda dapat menggunakannya dengan lambda standar:

void g()
{
    int sum;
    auto rec = [&sum](int i) -> int
    {
        static int (*inner)(int&, int) = [](int& _sum, int i)->int 
        {
            _sum += i;
            return i>0 ? inner(_sum, i-1)*i : 1; 
        };
        return inner(sum, i);
    };
}

Kerjanya di GCC 4.7

Anda dapat membuat panggilan fungsi lambda itu sendiri secara rekursif. Satu-satunya hal yang perlu Anda lakukan adalah merujuknya melalui pembungkus fungsi sehingga kompiler tahu itu kembali dan tipe argumen (Anda tidak dapat menangkap variabel - lambda itu sendiri - yang belum didefinisikan) .

  function<int (int)> f;

  f = [&f](int x) {
    if (x == 0) return 0;
    return x + f(x-1);
  };

  printf("%d\n", f(10));

Berhati-hatilah untuk tidak kehabisan ruang pembungkus f.

Untuk membuat lambda rekursif tanpa menggunakan kelas dan fungsi eksternal (seperti std::functionatau kombinator titik tetap) kita dapat menggunakan konstruksi berikut di C ++ 14 ( contoh langsung ):

#include <utility>
#include <list>
#include <memory>
#include <iostream>

int main()
{
    struct tree
    {
        int payload;
        std::list< tree > children = {}; // std::list of incomplete type is allowed
    };
    std::size_t indent = 0;
    // indication of result type here is essential
    const auto print = [&] (const auto & self, const tree & node) -> void
    {
        std::cout << std::string(indent, ' ') << node.payload << '\n';
        ++indent;
        for (const tree & t : node.children) {
            self(self, t);
        }
        --indent;
    };
    print(print, {1, {{2, {{8}}}, {3, {{5, {{7}}}, {6}}}, {4}}});
}

cetakan:

1
 2
  8
 3
  5
   7
  6
 4

Catatan, jenis hasil lambda harus ditentukan secara eksplisit.

Saya menjalankan benchmark membandingkan fungsi rekursif vs fungsi lambda rekursif menggunakan std::function<>metode penangkapan. Dengan optimalisasi penuh diaktifkan pada dentang versi 4.1, versi lambda berjalan lebih lambat.

#include <iostream>
#include <functional>
#include <chrono>

uint64_t sum1(int n) {
  return (n <= 1) ? 1 : n + sum1(n - 1);
}

std::function<uint64_t(int)> sum2 = [&] (int n) {
  return (n <= 1) ? 1 : n + sum2(n - 1);
};

auto const ITERATIONS = 10000;
auto const DEPTH = 100000;

template <class Func, class Input>
void benchmark(Func&& func, Input&& input) {
  auto t1 = std::chrono::high_resolution_clock::now();
  for (auto i = 0; i != ITERATIONS; ++i) {
    func(input);
  }
  auto t2 = std::chrono::high_resolution_clock::now();
  auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count();
  std::cout << "Duration: " << duration << std::endl;
}

int main() {
  benchmark(sum1, DEPTH);
  benchmark(sum2, DEPTH);
}

Menghasilkan hasil:

Duration: 0 // regular function
Duration: 4027 // lambda function

(Catatan: Saya juga mengonfirmasi dengan versi yang mengambil input dari cin, sehingga menghilangkan evaluasi waktu kompilasi)

Dentang juga menghasilkan peringatan kompiler:

main.cc:10:29: warning: variable 'sum2' is uninitialized when used within its own initialization [-Wuninitialized]

Yang diharapkan, dan aman, tetapi harus diperhatikan.

Sangat menyenangkan memiliki solusi di sabuk alat kami, tetapi saya pikir bahasanya akan membutuhkan cara yang lebih baik untuk menangani kasus ini jika kinerja harus sebanding dengan metode saat ini.

catatan:

Seperti yang ditunjukkan oleh komentator, sepertinya versi terbaru VC ++ telah menemukan cara untuk mengoptimalkan ini ke titik kinerja yang sama. Mungkin kita tidak membutuhkan cara yang lebih baik untuk menangani ini (kecuali untuk gula sintaksis).

Juga, seperti beberapa pos SO lainnya telah diuraikan dalam beberapa minggu terakhir, kinerja std::function<>itu sendiri mungkin menjadi penyebab fungsi pelambatan vs panggilan secara langsung, setidaknya ketika tangkapan lambda terlalu besar untuk masuk ke dalam beberapa std::functionpenggunaan ruang perpustakaan yang dioptimalkan untuk fungsi-fungsi kecil (Saya kira agak seperti berbagai optimasi string pendek?).

Ini adalah implementasi yang sedikit lebih sederhana dari operator fixpoint yang membuatnya sedikit lebih jelas apa yang sebenarnya terjadi.

#include <iostream>
#include <functional>

using namespace std;

template<typename T, typename... Args>
struct fixpoint
{
    typedef function<T(Args...)> effective_type;
    typedef function<T(const effective_type&, Args...)> function_type;

    function_type f_nonr;

    T operator()(Args... args) const
    {
        return f_nonr(*this, args...);
    }

    fixpoint(const function_type& p_f)
        : f_nonr(p_f)
    {
    }
};


int main()
{
    auto fib_nonr = [](const function<int(int)>& f, int n) -> int
    {
        return n < 2 ? n : f(n-1) + f(n-2);
    };

    auto fib = fixpoint<int,int>(fib_nonr);

    for (int i = 0; i < 6; ++i)
    {
        cout << fib(i) << '\n';
    }
}

Ini adalah versi yang lebih baik dari solusi Y-combinator berdasarkan pada yang diusulkan oleh @Barry.

template <class F>
struct recursive {
  F f;
  template <class... Ts>
  decltype(auto) operator()(Ts&&... ts)  const { return f(std::ref(*this), std::forward<Ts>(ts)...); }

  template <class... Ts>
  decltype(auto) operator()(Ts&&... ts)  { return f(std::ref(*this), std::forward<Ts>(ts)...); }
};

template <class F> recursive(F) -> recursive<F>;
auto const rec = [](auto f){ return recursive{std::move(f)}; };

Untuk menggunakan ini, seseorang dapat melakukan hal berikut

auto fib = rec([&](auto&& fib, int i) {
// implementation detail omitted.
});

Ini mirip dengan let reckata kunci di OCaml, meskipun tidak sama.

C ++ 14: Ini adalah stateless anonim rekursif / tanpa kumpulan generik lambdas yang menampilkan semua angka dari 1, 20

([](auto f, auto n, auto m) {
    f(f, n, m);
})(
    [](auto f, auto n, auto m) -> void
{
    cout << typeid(n).name() << el;
    cout << n << el;
    if (n<m)
        f(f, ++n, m);
},
    1, 20);

Jika saya mengerti benar ini menggunakan solusi Y-combinator

Dan ini adalah versi jumlah (n, m)

auto sum = [](auto n, auto m) {
    return ([](auto f, auto n, auto m) {
        int res = f(f, n, m);
        return res;
    })(
        [](auto f, auto n, auto m) -> int
        {
            if (n > m)
                return 0;
            else {
                int sum = n + f(f, n + 1, m);
                return sum;
            }
        },
        n, m); };

auto result = sum(1, 10); //result == 55

Inilah jawaban terakhir untuk OP. Bagaimanapun, Visual Studio 2010 tidak mendukung menangkap variabel global. Dan Anda tidak perlu menangkapnya karena variabel global dapat diakses secara global. Jawaban berikut menggunakan variabel lokal sebagai gantinya.

#include <functional>
#include <iostream>

template<typename T>
struct t2t
{
    typedef T t;
};

template<typename R, typename V1, typename V2>
struct fixpoint
{
    typedef std::function<R (V1, V2)> func_t;
    typedef std::function<func_t (func_t)> tfunc_t;
    typedef std::function<func_t (tfunc_t)> yfunc_t;

    class loopfunc_t {
    public:
        func_t operator()(loopfunc_t v)const {
            return func(v);
        }
        template<typename L>
        loopfunc_t(const L &l):func(l){}
        typedef V1 Parameter1_t;
        typedef V2 Parameter2_t;
    private:
        std::function<func_t (loopfunc_t)> func;
    };
    static yfunc_t fix;
};
template<typename R, typename V1, typename V2>
typename fixpoint<R, V1, V2>::yfunc_t fixpoint<R, V1, V2>::fix = [](tfunc_t f) -> func_t {
    return [f](fixpoint<R, V1, V2>::loopfunc_t x){  return f(x(x)); }
    ([f](fixpoint<R, V1, V2>::loopfunc_t x) -> fixpoint<R, V1, V2>::func_t{
        auto &ff = f;
        return [ff, x](t2t<decltype(x)>::t::Parameter1_t v1, 
            t2t<decltype(x)>::t::Parameter1_t v2){
            return ff(x(x))(v1, v2);
        }; 
    });
};

int _tmain(int argc, _TCHAR* argv[])
{
    auto term = [](int a)->int {
      return a*a;
    };

    auto next = [](int a)->int {
      return ++a;
    };

    auto sum = fixpoint<int, int, int>::fix(
    [term,next](std::function<int (int, int)> sum1) -> std::function<int (int, int)>{
        auto &term1 = term;
        auto &next1 = next;
        return [term1, next1, sum1](int a, int b)mutable ->int {
            if(a>b)
                return 0;
        else
            return term1(a) + sum1(next1(a),b);
        };
    });

    std::cout<<sum(1,10)<<std::endl; //385

    return 0;
}

Anda mencoba menangkap variabel (jumlah) yang sedang Anda tentukan. Itu tidak baik.

Saya tidak berpikir benar-benar self-recursive C ++ 0x lambdas adalah mungkin. Anda harus bisa menangkap lambda lain.

Jawaban ini lebih rendah daripada jawaban Yankes, tetapi tetap saja, inilah jawabannya:

using dp_type = void (*)();

using fp_type = void (*)(dp_type, unsigned, unsigned);

fp_type fp = [](dp_type dp, unsigned const a, unsigned const b) {
  ::std::cout << a << ::std::endl;
  return reinterpret_cast<fp_type>(dp)(dp, b, a + b);
};

fp(reinterpret_cast<dp_type>(fp), 0, 1);

Anda memerlukan kombinator titik tetap. Lihat ini .

atau lihat kode berikut:

//As decltype(variable)::member_name is invalid currently, 
//the following template is a workaround.
//Usage: t2t<decltype(variable)>::t::member_name
template<typename T>
struct t2t
{
    typedef T t;
};

template<typename R, typename V>
struct fixpoint
{
    typedef std::function<R (V)> func_t;
    typedef std::function<func_t (func_t)> tfunc_t;
    typedef std::function<func_t (tfunc_t)> yfunc_t;

    class loopfunc_t {
    public:
        func_t operator()(loopfunc_t v)const {
            return func(v);
        }
        template<typename L>
        loopfunc_t(const L &l):func(l){}
        typedef V Parameter_t;
    private:
        std::function<func_t (loopfunc_t)> func;
    };
    static yfunc_t fix;
};
template<typename R, typename V>
typename fixpoint<R, V>::yfunc_t fixpoint<R, V>::fix = 
[](fixpoint<R, V>::tfunc_t f) -> fixpoint<R, V>::func_t {
    fixpoint<R, V>::loopfunc_t l = [f](fixpoint<R, V>::loopfunc_t x) ->
        fixpoint<R, V>::func_t{
            //f cannot be captured since it is not a local variable
            //of this scope. We need a new reference to it.
            auto &ff = f;
            //We need struct t2t because template parameter
            //V is not accessable in this level.
            return [ff, x](t2t<decltype(x)>::t::Parameter_t v){
                return ff(x(x))(v); 
            };
        }; 
        return l(l);
    };

int _tmain(int argc, _TCHAR* argv[])
{
    int v = 0;
    std::function<int (int)> fac = 
    fixpoint<int, int>::fix([](std::function<int (int)> f)
        -> std::function<int (int)>{
        return [f](int i) -> int{
            if(i==0) return 1;
            else return i * f(i-1);
        };
    });

    int i = fac(10);
    std::cout << i; //3628800
    return 0;
}