template <typename OO, typename Sep> 
OO split(std::string const& source, OO dest, Sep sep)
{
    std::string::size_type p = 0;
    while (p != std::string::npos)
    {
        const std::string::size_type p2 = source.find_first_of(sep, p);
        if (p2 != std::string::npos) {
            *dest++ = source.substr(p, p2-p);
            p = p2 + 1;
        } else {
            *dest++ = source.substr(p);
            p = p2;
        }
    }
    return dest;
}

void eraseLine(const char* pathFile,unsigned int lineToErase)
{

    std::string buffer = ""; 
    std::ifstream input(pathFile);


    //si le fichier est bien ouvert
    if (input) 
    {

        std::string pathOutput;

        {
            std::ostringstream tmpflx;

            //time sert à garantir l'unicite du fichier temporaire
          tmpflx<<pathFile<<"_tmp"<<time(0); 
          pathOutput=tmpflx.str();
      }

      std::ofstream output(pathOutput.c_str());
      if(output)
      {
          int line = 0;
          while ( std::getline( input, buffer) ) 
          {
            line++;
            if(line != lineToErase)
                output<<buffer+"\n";
          }
    
          input.close();
          output.close();
          
          std::remove(pathFile);
          std::rename(pathOutput.c_str(),pathFile);
      }
    }
}

/*
Excerpted from "C++ Cookbook" by Ryan Stephens, Christopher Diggins,
Jonathan Turkanis, and Jeff Cogswell. Copyright C 2006 O'Reilly Media, Inc.
All rights reserved. Used with permission.
Published by O'Reilly Media, Inc.
To purchase this book go to: http://oreilly.com/catalog/9780596007614/
*/

#include <iostream> 
#include <iomanip> 
#include <string> 
#include <list> 
#include <vector> 

// TableFormatter formats data for output to a stream of characters 
// of type T. 

template<typename T> 
class TableFormatter { 
public: 
    TableFormatter(std::basic_ostream<T>& os) : out_(os) {} 
  ~TableFormatter( ) {out_ << flush;} 

    template<typename Cont> // refers to mem fn template param list 
    void writeTableRow(const Cont& v, int width) { 
       ios_base::fmtflags flags = out_.flags( ); 
       out_.flush( ); 
       out_ << setprecision(2) << fixed;  // Set the precision, in case 
       // this is floating-point data 
       for (typename Cont::const_iterator p = v.begin( ); 
            p != v.end( ); ++p) 
           out_ << setw(width) << left << *p;  // Set the width, justify, 
       // and write the element 
       out_ << endl;     // Flush 
       out_.setf(flags); // Set the flags back to normal 
    } 

 

private: 
    std::basic_ostream<T>& out_; 
};

int main( ) { 
   TableFormatter<char> fmt(cout); 
   vector<string> vs; 
   vs.push_back( "Sunday" ); 
   vs.push_back( "Monday" ); 
   vs.push_back( "Tuesday" ); 


   vector<string> vs2; 
   vs2.push_back( "John" ); 
   vs2.push_back( "Susie" ); 
   vs2.push_back( "Alan Smith" ); 

   fmt.writeTableRow(vs, 12); 
   fmt.writeTableRow(vs2, 12); 

   list<double> vd; 
   vd.push_back(4.0); 
   vd.push_back(3.0); 
   vd.push_back(2.0); 

   fmt.writeTableRow(vd, 12); 
}