C++ ta 2 farklı syntax ile fonksiyon tanımlandığını öğrendim

#include <iostream>

auto foo(int x, int y)->int {

	return x + y;
}
int foo1(int x, int y) {

	return x + y;
}

int main() {

	std::cout<<foo(15, 25);
       std::cout << foo1(5, 65);
}

Burda bu 2 fonksiyon arasındaki fark nedir ? Ve nerede hangisini kullanacağımı nasıl bilebilirim ?

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ben bu gönderdiğin syntax'a yakın bir kullanım olarak şunu biliyorum sadece :

vector a;
std::find( a.begin(), ,a.end(), [](int curVal) -> bool {
return curVal == 5;
});

Bu dönüş değerini lambda'larda "-> bool" gibi belirtmezsek Vs 2010 derleyemiyor bunu.

Yani visual studio 2010 'da dönüş değerli bir lambda kullanmak istiyorsak "-> tür" kullanmak zorundayız.

Bu sorunuda vs2012 'de çözdüler sonra.

Başka bir kullanım alanı bilmiyorum ne yazıkki.

Erdemdem.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ben de ilk gördüğümde lambda fonksiyonları sanmıştım. Hatta uzun bir süre öyle kaldı kafamda :). Ama

lamdadan farklı olduğunu "[]" parentezler olmayınca farkettim. Bildiğim kadarı ile lambda da "[]"

kullanılmadan bir tanımlama biçimi yok.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Anladım. Aklımda hala lambda olarak kalmaya devam etsin o zaman. :) Yardımlarınız için teşekkürler.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Bildiğim kadarıyla, dönüş türünün işlev parametre listesinden sonra '->' ile bildirilmesi, yine de lambda olanağı ile gelen bir olanak. C++'ın mevcut söz dilimi dönüş türüne izin vermediğinden lambdalarda öyle sonradan bildirilmesi gerekti. Öyle olması gerekince bu yeni söz dizimini normal işlevlere de genellediler.

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Normal fonksyon yazarken cok bir farki yok gibi gorunse de bu stilin (trailing return type deniyor) normal fonksyon tanimina gore ufak bir ustunlugu var: scope. Trailing return type'da kullandigimiz isimler, fonksyonun govdesindeymis gibi derleniyor.

Ornegin asagidaki sinifa bir uye fonksyon yazdigimizi dusunun:

struct foo
{
   using map_t = std::map<std::string, std::string>;
   using elem_t = map_t::iterator;

   elem_t get_elem(const std::string& key);
private:
   map_t m_map;
};

get_elem fonksyonunu normal bicimde yazmak isterseniz dogrudan elem_t olarak donus tipi koyamazsiniz:

// derlenmeyecek
elem_t foo::get_elem(const std::string& key) {
   return m_map[key];
}

Fakat ayni fonksyonu trailing return type formatinda yazarsaniz, tum isimler dogru scope'lardan gelecek:

auto foo::get_elem(const std::string& key) -> elem_t {
   return m_map[key];
}

Ayni sekilde fonksyona gelen parametreleri de normal stilin aksine trailing return type stiliyle kullanabiliyorsunuz, decltype gibi araclar ile.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Cevabınız için teşekkürler. Araştırırken

auto main()->int{
   //main function
}

Bu şekilde bir main tanımlandığını gördüm. Peki bu tanımlamanın bizim için bir artısı var mıdır ?

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Fatihin dediği konu çok ilginçmiş gerçekten valla bilmiyordum o kullanımı.

Ben main konusunda bir artısını düşünüyorum o da mülakatlarda kullanıp artislik yapmak :)

Erdemdem

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (kerdemdemir):

Size katılıyorum. Ama tanımlama biçimi normale göre biraz daha havalı gibi :)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]