#include <iostream>
using namespace std;
int add(int x , int f){return x+f;}
auto f = [](int xx){return xx;};
enedil napisał(a):
W skrócie, nie masz nic w tym dobrze. W szczególności, żadna z funkcji, które napisałeś nie zwraca funkcji lambda.
funkcja::
int add(int x , int f){return x+f;}
Patryk27 napisał(a):
Napisz funkcję (zwykłą), która przyjmuje parametr typu int.
Gdzie masz tę funkcję?
Funkcja::
int add(int x , int f){return x+f;}
Trochę researchu zrobić:
https://stackoverflow.com/questions/4726768/function-returning-a-lambda-expression
sssebastianb5 napisał(a):
enedil napisał(a):
W skrócie, nie masz nic w tym dobrze. W szczególności, żadna z funkcji, które napisałeś nie zwraca funkcji lambda.
funkcja::
int add(int x , int f){return x+f;}
No nie zwraca funkcji lambda, zwraca sumę liczb, a nie funkcję.
enedil napisał(a):
sssebastianb5 napisał(a):
enedil napisał(a):
W skrócie, nie masz nic w tym dobrze. W szczególności, żadna z funkcji, które napisałeś nie zwraca funkcji lambda.
funkcja::
int add(int x , int f){return x+f;}No nie zwraca funkcji lambda, zwraca sumę liczb, a nie funkcję.
czyli ,co mam napisać funkcję lambda w następujący sposób ?
auto l = [] (int x, int y) { return x + y; };
auto add() -> decltype ([](int x) -> int)
{
return [](int x) { return x; }
}
chodzi może o ten zapis ?
Coś tego typu, tylko jeszcze pozostaje zgodność z resztą założeń zadania (np. fajnie żeby funkcja add coś dodawała gdzieś).
Możesz również pominąć jawną deklarację typu zwracanego (z pewnością jeśli użyjesz -std=c++2a -fconcepts, nie wiemczy bez tego działa)
co powiesz teraz ?
auto add() -> decltype ([](int x ,int y) -> int)
{
return [](int x,int y) { return x+y; };
}
A nie chodzi o jakieś:
auto add(int x){
auto fun = [x] (int y) { return x + y; };
return fun;
}
(pewnie trochę zła składnia ale nie umiem w lambdy w c++)
edit: fixed
Masz funkcje add która dla argumentu int zwraca nową funkcje, która dla argumentu int zwraca sumę tych 2 intów.
x.
[Error] expected '}' at end of input
auto add(int x){
auto fun = [x] (int y) { return x + y; };
return fun;
}
Shalom napisał(a):
u mnie działa
*mam dalej błąd po skopiowaniu kodu:
,, [Error] 'add' function uses 'auto' type specifier without trailing return type""
auto i bez -> na końcu to C++14.
auto first(int x) {
auto lambda = [x](int y){ return x+y; };
return lambda;
};
auto func = first(2);
auto lambda = func(6);
cos takiego ?
@Edit
sssebastianb5 napisał(a):
Shalom napisał(a):
u mnie działa*mam dalej błąd po skopiowaniu kodu:
,, [Error] 'add' function uses 'auto' type specifier without trailing return type""
przełącz wersję języka na nowszą, co najmniej c++14
enedil napisał(a):
sssebastianb5 napisał(a):
Shalom napisał(a):
u mnie działa*mam dalej błąd po skopiowaniu kodu:
,, [Error] 'add' function uses 'auto' type specifier without trailing return type""
przełącz wersję języka na nowszą, co najmniej c++14
*Super wszystko działa wielkie dzięki :)
tak tylko zostawiam:
# dummy lambda discussion:)
def f(x):
return lambda y: y + x
print(f(41)) # function bla bla bla
print(f(41)(1)) # 42
let f = x: y: x + y; in f 41 1 (nix) :-P
Jest taka prezentacja "Fun with Lambdas": https://www.slideshare.net/SumantTambe/fun-with-lambdas-c14-style
Krok po kroku pokazuje coraz to bardziej pokręcone lambdy, ta na slajdzie 19 to już prawie-to-o-co-tu-chodzi, bo zapamiętuje parametr, trzeba by tylko dodawanie dołożyć.
Tutaj przykład zwracanej lambdy w ogólnej formie ( C++17 )
template< typename ...Arg >
auto sum( Arg&&... args )
{
return [ args = std::make_tuple( std::forward<Arg>(args) ... ) ]( auto a )
{
return a + std::apply( [](auto&& ... args ){ return (args+...); } , std::move(args) );
};
}
......
std::cout << sum(41)(1) << std::endl; // = 42
std::cout << sum(1,2,3)(-1) << std::endl; // = 5
std::cout << sum(1.6,-2.1,3)(-0.01) << std::endl; // = 2.49
std::cout << sum('b',-'a')(0) << std::endl; // = 1
std::cout << sum(0.01,'c',-34.6,0.6,8.7)(20.0) << std::endl; // = 93.71
std::cout << sum(" is"s, " my"s, " name"s)("This"s) << std::endl; // = "This is my name"
A ja wysmażyłem coś takiego (fold expressions for the win):
#include <iostream>
auto sum() {
return []<typename ...Args>(Args&&... args){return (args + ...);};
}
int main() {
std::cout << sum()(1, 2, 3, 4) << std::endl;
}
$ g++ test.cpp -o test -std=c++17
$ ./test
10
Z parametrem to
#include <iostream>
template <class T>
auto sum(T i) {
return [i]<typename ...Args>(Args&&... args){return (args + ... + i);};
}
int main() {
std::cout << sum(10)(1, 2, 3, 4) << std::endl;
}
$ g++ test.cpp -o test -std=c++17
$ ./test
20
Albo na całego:
#include <iostream>
template <class ...T>
auto sum(T&&... t) {
return [t...]<typename ...Args>(Args&&... args){return (args + ... + (t + ...));};
}
int main() {
std::cout << sum(10, 10, 10)(1, 2, 3, 4) << std::endl;
}
$ g++ test.cpp -o test -std=c++17
$ ./test
40
Zarejestruj się i dołącz do największej społeczności programistów w Polsce.
Otrzymaj wsparcie, dziel się wiedzą i rozwijaj swoje umiejętności z najlepszymi.
która przyjmuje parametr typu int- Twoja przyjmuje dwa inty.