function to iterate over members and call function passed as argument

I have a std::vector<T> of some type that's part of a class and that I need to iterate through in a lot of different places in my code, so I thought I'd be smart and create a function IterateAttributes, and pass it a boost::function object that I can in the loop and pass a single element and then I can pass any function to do work on the elements.

This seems a good idea until you have to implement it, then the problem comes of what does the passed in function return and does it need other arguments. It seems like I either have to find a way to do this more generically, like using templates, or I have to create overloads with function objects taking different args.

I think the first (more generic) options is probably better, however how would I go about that?

Below is a trial that doesn't work, however if I wanted to have a number of args, and all but the Attribute (a struct) arg mandatory. How should I go about it?

template <开发者_开发知识库;typename T> template <typename arg>
void ElementNode::IterateAttributes(boost::function<T (arg, Attribute)> func_)
{
    std::vector<Attribute>::iterator it = v_attributes.begin();

    for (; it != v_attributes.end(); it++)
    {
        func_(arg, *it);
    }
}

Is that what you mean:

template <typename T, typename arg>
void ElementNode::IterateAttributes(boost::function<T (arg, Attribute)> func_, arg a)
{
    std::vector<Attribute>::iterator it = v_attributes.begin();

    for (; it != v_attributes.end(); it++)
    {
        func_(a, *it);
    }
}

that allows only one parameter of any type - if you want you can introduce also version for more parameters.

About return value - what to do about it depends on what value it acctually is - the generic (and probably unnecesary) solution would be to return std::list<T>, but that would create more problems than it would solve i guess. If return type varies (not only in type but also in meaning) then I suggest modyfying templated function so it takes reference/pointer to overall result and updates it accordingly:

template <typename T> template <typename arg>
void ElementNode::IterateAttributes(boost::function<voidT (arg, Attribute, T&)> func_)
{
    std::vector<Attribute>::iterator it = v_attributes.begin();
    T result;

    for (; it != v_attributes.end(); it++)
    {
        func_(arg, *it, result);
    }
    return result;
}

That's a quick workaround, it works but it's ugly, error prone, and pain to debug.

If you want variable parameter amount, then you would have to create several templates of above function - i just tested if it's possible:

template <typename T>
 T boo(T){

}

template <typename T, typename TT>
TT boo(T,TT){

}

void test()
{
    int i;
    i= boo<int>(0);
    i=boo<int,double>(0,0.0);
}

You must remember that functions passed to IterateAttributes must match exatly parameters given to Iterate function. That also means that you cannot use in it's prototype default values - probably you will have to define several overloaded versions like

void func_(Attribute,arg1, arg2,arg3){...}
void func_(Attribute A,arg1 a1,arg2 a2){func_(A,a1, a2,default3);}
void func_(Attribute A,arg1 a1){func_(A,a1, default2,default3);}
void func_(Attribute A){func_(A,default1, default2,default3);}

a) You want to iterate over the array and do something with each element there: in this case, you want functions that all take an array element and return void. Simple.

b) You want to partially apply functions with more arguments on each element: Write a custom functor around your function which stores the additional, pre-assigned arguments, or use boost::bind to effectively do the same.

Example:

vector<string> myStrings; // assign some values

// define a function with an additional argument
void myFunc(string message, string value)
{
  cout << message << value << endl;
}

// allow partial application, i.e. "currying"
struct local_function
{   
  static string message;

  static void myFunc_Curried(string value)
  {
    myFunc(message, value);
  }    
};

local_function::message = "the array contains: ";

// apply the curried function on all elements in the array
for_each(myStrings.begin(), myStrings.end(), local_function::myFunc_Curried);

The functor operates statically only for demonstration purposes. If message is bound to an instance of the struct, you will need something like boost::bind anyway to bind the instance pointer this in order to actually call the curried function. However, if the function I want to apply is used only locally, I prefer following the more readable static approach.

What you are trying to accomplish makes very good sense, and is also built directly into functional languages (for example F#). It is possible to achieve in C++, but requires some workarounds in the aforementioned case b. Please note if writing your own functor, as in my example, that it is common to place the arguments you want to curry away always at the beginning, and to "fill in" the arguments from the beginning to the end when partially applying.

Summarizing the comments and more thoughts:

Use bind to bind the other arguments, then use for_each on the resulting functor.

To handle return values, you need to think about what the return values mean. If you need to use the values in some way (say, perform a reduction, or use them to influence whether or not to continue performing the operation, etc), then you can use another functor to wrap the original to perform the thing you want.

You could do the same or more using BOOST_FOREACH or C++0x for each. That would even take less code to write.