Question

I tried to create a string splitting template like the following, I get errors.

struct splitX
{
  enum empties_t { empties_ok, no_empties };
};

template <typename Container>
Container& split(
  Container&                                 result,
  const typename Container::value_type&      s,
  typename Container::value_type::value_type delimiter,
  splitX::empties_t                           empties = splitX::empties_ok )
{
  result.clear();
  std::istringstream ss( s );
  while (!ss.eof())
  {
      typename Container::value_type field;
      getline( ss, field, delimiter );
      if ((empties == split::no_empties) && field.empty()) continue;
      result.push_back( field );
  }
  return result;
}

This fails with the error from the headline when I’m trying to use it with the vector class like below:

std::getline(myfile,line);
std::vector<std::string> fields;
split(fields,line,' ');

// Test split function
std::cout << line << std::endl;
for(int i = 0; i < fields.size();i++)
  std::cout << fields[i];

Answer 1

Ok, Microsoft Visual C++ 2008 doesn’t like your Container::value_type::value_type.

You can use this monstrous construction:

template <typename T>
struct vte /*value_type_extractor*/
{
    typedef typename T::value_type type;
};

template <typename Container>
Container& split(
   Container&                                 result,
   const typename Container::value_type&      s,
   typename vte<typename vte<Container>::type>::type delimiter,
   splitX::empties_t                           empties = splitX::empties_ok )
{
  typedef typename Container::value_type string_type;
  typedef typename string_type::value_type elem_type;
  std::basic_istringstream<elem_type> ss( s );
  ...
}

Or, you can do it in STL style:

#inlcude <iterator>

template <typename OutputIterator, typename StringType>
OutputIterator split(
  OutputIterator                  out,
  const StringType&               s,
  typename StringType::value_type delimiter,
  splitX::empties_t               empties = splitX::empties_ok )
{
  typedef typename StringType::value_type elem_type;
  std::basic_istringstream<elem_type> ss( s );
  while (!ss.eof())
  {
      StringType field;
      std::getline( ss, field, delimiter );
      if ((empties == splitX::no_empties) && field.empty()) continue;
      *out++ = field;
  }
  return out;
}

//somewhere in code
{
    ...
    split(std::back_inserter(your_container), line, ' ');
}

Or, you can stop pretending to be a template god and write two overloaded functions:

template <typename Container>
Container& split(
   Container&              result,
   const std::string&      s,
   char                    delimiter,
   splitX::empties_t       empties = splitX::empties_ok )
{
  std::istringstream ss(s);
  ...
}

template <typename Container>
Container& split(
   Container&              result,
   const std::wstring&     s,
   wchar_t                 delimiter,
   splitX::empties_t       empties = splitX::empties_ok )
{
  std::wistringstream ss(s);
  ...
}