ATL / WTL / STL

void closer(const std::pair<string,ofstream*>& toClose)
{
    toClose.second->close();
}

for_each(outputFiles.begin(), outputFiles.end(), closer);

template <typename TPair>
struct select_second : public std::unary_function<TPair, typename TPair::second_type> {
      result_type operator()(argument_type p) const {
      return p.second;
   }
};

// It takes 2 functors, f and g, and compose them into f o g, i.e., f(g(x))
template <typename F, typename G>
struct composed_fn : public std::unary_function<typename G::argument_type, typename F::result_type> {
   const G& g;
   const F& f;
   composed_fn(const F& f_, const G& g_) : g(g_), f(f_) { }
 
   result_type operator()(argument_type x) const {
      return f(g(x));
   }
};
 
template <typename F, typename G>
composed_fn<F, G> compose(const F& f, const G& g) {
   return composed_fn<F, G>(f, g);
}

for_each(outputFiles.begin(), outputFiles.end(), compose(std::mem_fun(&std::ofstream::close), select_second<FileMap::value_type>()));

#include <vector>
#include <string>

std::vector< std::string > parseString(const std::string& strin)
{
    std::string str = strin;
    std::vector< std::string > words;
    size_t splt = str.find("~");

    while(splt != string::npos)
    {
        string out = str.substr(0,splt);
        words.push_back( out );
        str = str.substr(splt+1,str.length());
        splt = str.find("~");
    }
    words.push_back( str );
    return words;
}