C++ function call - c++

Question

Imagine function func that needs var during run time. Is it possible under c++ to call func without var as a parameter? That is, to have something like this
func(var, i) = func(i);
I would like to do so for the sake of simple readability. Inside my class I could set var as a global parameter and then call only func(i) but this would give troubles if I was going to use threads...
But note that func uses var during run time. Ex:
int func(int var , int i){
return i+var;
}
In fact I will have multiple calls of func(), but all thes calls share the same var. Ex: instead of
int var=2;
int res= func(var, 0) + func(var, 1) +..... func(var, n);
I would write more concisely (in it is the same var)
int var=2;
int res= func(0) + func(1) +..... func(n);

Answer 1

You can do this using lambdas:
auto bound_func = [var](auto i) { return func(var, i); }
Or you can have more freedom by just storing the var in a struct:
struct func_binder
{
var v_;
func_binder(var v)
: v_(v)
{ }
decltype(func(v_, i)) operator()(int i)
{
return func(v_, i);
}
};
This can be used like:
func_binder f(some_var);
f(some_i);
If var is isn't mutated by the function, then you don't need to worry about it with threads. If it is, then it should be wrapped in a structure that that synchronizes access to it somehow.

Answer 2

How about?:
auto func_binded = std::bind( func, var, std::placeholders::_1 );

Answer 3

Add a new function with the same name that takes the parameter i. This function can call the other function with
The correct var. This is called function overloading.
func(i){
func(global_var, i);
}

Answer 4

When declaring your function, you can specifiy a default argument. In your case it has to be the last parameter of your function.
void func(int i, int var=0);
then call it like that func(i);
which is func(i, 0);

Answer 5

yes you can use a default value for you var variable
declare the prototype like this:
fun(type_of_i i,typeofvar var=default_value);
try to use the most relevant value for the default value
Of course you must be able to permute the order of parameters, otherwise use the function overloading mechanism as said in a previous answer
regards

Answer 6

So, you have at least two solutions, the first one is simple to add to a class :
Use variadic template to build a wrapper function (my preferred solution in your case, easy to add to a class). This solution allows you to write int r = newfunc(var, 1, 2, 3); instead of repeating again and again function name :
int funcvar(int var)
{
return 0;
}
template<typename TFirst, typename ... T>
int funcvar(int var, TFirst first, T ... args)
{
return func(var, first) + funcvar(var, args...);
}
Use lambda (a little be difficult to add to a class, because you need a variable of type like std::function<int(int)> fvl and initialized in constructor or pass it by argument):
auto fvl = [var](int i) { return func(var, i); };
examples :
int main()
{
int var = 1;
// Use of variadic template
int result1 = funcvar(var, 1, 2, 3, 4, 5);
int result2 = funcvar(var, 5, 6);
// Use of lambda
auto fvl = [var](int i) { return func(var, i); };
int result3 = fvl(1) + fvl(2) + fvl(3) + fvl(4) + fvl(5);
int result4 = fvl(5) + fvl(6);
std::cout << result1 << std::endl;
std::cout << result2 << std::endl;
std::cout << result3 << std::endl;
std::cout << result4 << std::endl;
}
see here