[c++] ostram method

#ifndef STRINGL_H#define STRINGL_H#include <string>#include <vector>#include <iostream>using namespace std;class StringList{public:    StringList(){};    StringList(string &str, string &delim) { addStrTokenz(str,delim); };    ~StringList(){};    void clear(){ list.clear(); };    void push_back(const string &str);    string getString(unsigned i);    void addStrTokenz(const string &str,const string &delim);    StringList strOfSizeBelow(StringList &strLst, const unsigned size);    StringList noDuplicate(StringList &strLst);    bool find(string &str);    float averageLength();    unsigned size(){ return (unsigned)list.size(); };    friend ostream & operator <<( ostream & os, const StringList & strLst );private:    unsigned outPerLine;    vector<string> list;};#endif

#include "stringl.h"// Left as an exercise: find out what else has to be #included from the// standard library headers to make everything work. :)void StringList::push_back(const std::string& str){    list.push_back(str);}// This one should also be marked const.std::string StringList::getString(unsigned i) const{    return list; // parentheses are unnecessary here}// Helper functions that translate the string find algorithms to use// iterators instead (more convenient here).std::string::iterator find_first_of(const std::string& delimiters, std::string::iterator position, const std::string& in) {    std::string::size_type index = std::distance(in.begin(), position);    std::string::size_type result = in.find_first_of(delimiters, index);    if (result == std::string::npos) { return in.end(); }    std::advance(position, result - index);    return position;}std::string::iterator find_first_not_of(const std::string& delimiters, std::string::iterator position, const std::string& in) {    std::string::size_type index = std::distance(in.begin(), position);    std::string::size_type result = in.find_first_not_of(delimiters, index);    if (result == std::string::npos) { return in.end(); }    std::advance(position, result - index);    return position;}// A hopefully clearer renaming of the function.// Referring to "string tokens" is redundant :)void StringList::addTokensFrom(const std::string& from, const std::string& delimiters){    // I don't think this really needs as much commenting as you had.     // But now I've added more comments to explain to you specifically why    // I've changed things in certain ways. :)    // The next non-empty token is found between 'start' and 'end' since    // we skip delimiters before 'start' (skipping empty tokens) and search    // for the next delimiter after that.    std::string::iterator begin = find_first_not_of(delimiters, from.begin(), from);    std::string::iterator end = find_first_of(delimiters, begin, from);    // You actually only want to check the begin position in your while    // condition. Otherwise you won't get to add the last word. This is why    // the iterator approach is more convenient: it's hard/ugly to account for    // npos in substring operations.    while (begin != from.end())    {        // Extract the word from the list and add it.        list.push_back(std::string(begin, end));        // Find the next word.        begin = find_first_not_of(delimiters, end, from);        end = find_first_of(delimiters, begin, from);    }}// Helper for filtering the list.struct notShorterThan {   int value;   notShorterThan(int value): value(value) {}   bool operator()(const std::string& s) { return s.size() >= value; }};// Again with the renaming. It's long, but...// Also, there's no reason to accept a StringList parameter here; you can have// it operate on 'this' instead. (If it was a static function before, you'll// need to change that.)StringList StringList::withOnlyStringsShorterThan(const unsigned size) const{    StringList result;    std::remove_copy_if(list.begin(), list.end(), result.list.begin(), notShorterThan(size));    return result;}// Similarly here. Note that there is a faster way to remove duplicates from// a list: if you sort it first, duplicates will always be adjacent, and the// standard library provides an algorithm that removes adjacent duplicates in// a single pass. Of course, sorting would change the object, so we make a// copy first, and then modify the copy in place.StringList StringList::withoutDuplicates() const{    StringList result(*this);    std::sort(result.list.begin(), result.list.end());    result.list.erase(std::unique(result.list.begin(), result.list.end()), result.list.end());    return result;}// Again, the standard library knows how to find things in general containers.// And don't call something "find" if it returns a boolean :)bool StringList::contains(std::string& toMatch){    return std::find(list.begin(), list.end(), toMatch) != list.end();}// At this point I'm mostly just showing off. ;)unsigned addLengthOf(unsigned accumulator, const std::string& s){    return accumulator + s.size();}float StringList::averageLength() const{    return float(std::accumulate(list.begin(), list.end(), 0, addLengthOf)) / list.size();}ostream& operator<<(ostream & os, const StringList& sl){    // A small simplification.    unsigned count = 0;    for(unsigned i = 0; i < strLst.size(); i++)    {        os << strLst.getString(i);        count++;        if (count == 2) {            os << '\n';            count = 0;        }    }    return os;}