Use of std::function in c++

omhari's blog

By omhari, history, 2 years ago, In English

Is there any difference between normal function

Code

#include<bits/stdc++.h>
using namespace std; 

int square(int a)
{
    return a*a;
}
int main() 
{
    cout<<square(5);
    return 0; 
}

and a function created using std::function

Code

#include<bits/stdc++.h>
using namespace std; 

int main() 
{
    function<int(int)> square=[&](int a){
        return a*a;
    };

    cout<<square(5);
    return 0; 
}

c++

omhari
2 years ago
9

Comments (9)

Write comment?

d0t_d0t

2 years ago, # |

+10

Yep -> Here

→ Reply

defnotmee

2 years ago, # |

← Rev. 3 →

+11

So i've extensively and exclusively used std::function for a long time (not anymore, for the reasons ill state) and this is what i have to say:

The main advantage of std::function over regular functions is that you cam make functions that use variables inside the scope youre in. It's a lot of times, very unpractical to create helper functions that make use of variables or arrays inside the code, and creating it inside the main function is valuable in those situations
The main problem with std::function is that its slow (specially if the ammount of captures you use is large) and replaceable by lambda functions (they have the same declaration, except with auto instead of std::function).
Lambdas are faster and a lot of the times more practical. The only problem with them is that recursion is iffy, you need to pass the own function as paremeter, however with std::function you need to include the parameters and return type in the typename, which is equally annoying.

→ Reply

ivan100sic

2 years ago, # ^ |

IMO you don't ever need std::function in competitive programming. Whenever you want to pass a function as a parameter to another function, use auto (C++20) or template functions (before C++20), or if you're passing it to a constructor, use a template class.

Regarding your last point, both approaches have some flaws, but in my experience auto self is shorter and of course it doesn't have any overhead.

→ Reply

defnotmee

2 years ago, # ^ |

Agreed. Reading again i see i didnt make it clear that i switched for lambdas (now its editted)

→ Reply

oversolver

2 years ago, # |

← Rev. 2 →

-11

if you are one who doesn't like self passing shit in lambdas but at the same time hate typing signature for std:: function I recommend this short define:

#define fun(T, name, ...) function<T(__VA_ARGS__)> name = [&](__VA_ARGS__)->T

and just code like usual function:

fun(void, dfs, int v, int p) {
    //body
};

P. S. I know about slowness and about y_combinator

→ Reply

oversolver

2 years ago, # ^ |

oh, someone explain me this downvote mania

→ Reply

psychobot

2 years ago, # ^ |

they didn't got uhh

→ Reply

alwyn

2 years ago, # ^ |

← Rev. 2 →

-8

Alternative

auto dfs = [&](auto self, int u, int p) -> void {
  #define dfs(...) self(self, __VA_ARGS__)

  for (int v : adj[u]) {
    if (v != p) {
      dfs(v, u);
    }
  }

  #undef dfs
};

→ Reply

thanhchauns2

2 years ago, # |

← Rev. 2 →

Yes, take an example:

First code

#include <bits/stdc++.h>
using namespace std;
int a;
int factorial_of_a()
{
	int x = 1;
	for (int i = 1; i <= a; i++) x *= i;
	return x;
}
int main()
{
	a = 10;
	cout << factorial_of_a() << '\n';
}

Second code, with the exactly same usage

#include <bits/stdc++.h>
using namespace std;
int main()
{
	int a = 10;
	function<int()> factorial_of_a = [&]()
	{
		int x = 1;
		for (int i = 1; i <= a; i++) x *= i;
		return x;
	};
	cout << factorial_of_a() << '\n';
}

You don't really need global variables when using std::functions.

→ Reply