How to provide the function signature for a function taking iterators of stl containers?

It depends on how generic you want the function to be. If the iterator types have to match, then

template <typename T>
void my_func(T i1, T i2)
{
    std::for_each(i1,i2,...); //dumb example implementation
}

is all you need. If you want them to be able to be different, then you just need another template parameter like

template <typename T, typename U>
void my_func(T i1, U i2)
{
    std::for_each(i1,i2,...); //dumb example implementation
}

Finally, if you don't like dealing with templates you can use a lambda instead and let the compiler take care of this for you. That would give you

auto my_func = [](auto i1, auto i2)
{
    std::for_each(i1,i2,...); //dumb example implementation
};

You could write a templated function

template<typename Iterator>
void my_func(Iterator startIter, const Iterator endIter)
{
  std::for_each(startIter, endIter, /* lambda */);
}

---

In case of wondering, how to pass the third parameter of the std::for_each, you could provide one more template parameter

const auto defaultCallable = [](auto element){ }; // does nothing
template<typename Iterator, typename Callable = decltype(defaultCallable)>
void my_func(Iterator startIter, const Iterator endIter, Callable func = {})
{
    std::for_each(startIter, endIter, func);
}

The syntax is not too obscure! The following way uses the range for at the point of use:

template <template<typename...> class Iterable, typename T>
void foo(
    const Iterable<T>& y // the container
){
    for (auto&& e : y){
        // e is the 'thingy' in the container.
    }
}

and you can pass any iterable container of arbitrary type to foo.