Reading and Storing in String STL

The above code reads all the lines from the text file samp.txt. But I need to read the lines 3 to 6. How to read the lines 3 to 6 that starts with the word "begin" and ends with the word "end"?. Please explain with the sample code.

Either use a line counter or do a find to look for "begin"/"end". The following uses find...

--------8<--------
#include <iostream>
#include <fstream>
#include <string>

int main()
{
        std::ifstream f("samp.txt");           // Process this file
        std::string str;                             // Reading lines into str
        bool processing = false;                // Flag set true, while processing
        while (getline(f,str)) {                   // Read line into str
                if (str.find("begin") == 0) {    // String starts with "begin"?
                        processing = true;        // Start processing
                        continue;                     // .. but ignore this line
                }
                else if (str.find("end") == 0)  // Start starts with "end"
                        processing = false;       // Stop processing
                if (processing) {                   // Are we processing?
                        // Do something with your string
                        std::cout << "Do something with \"" << str << "\"\n";
                }
        }
}
--------8<--------

Hi sarahsthss,
Is this homework? It definitely smells like homework.

Cheers,
Stefan

Thanks for your reply. Between "begin" and "end", there are 2 lines as follows:

    a: 12,0.7,12,12.5
    b: text, 23, 24, 10
I have to read the first line after colon(:) and store 12 , 0.7,12 and 12.5 in separate variables. Like that, I have to do for the 2 nd line. Please explain me with the sample code.

sarahsthss,
Some considerations which may help you:
1. How do you convert from a text line into a set (array) of values?
   -> Walk an index to the first colon.
   -> Loop:
        Skip over comma or spaces.
        Mark begin of value start.
        walk your index until comma or end of string.
        copy what you found in a new string. Convert it eventually.
      Until end of string
     
2. Which type do you use to store your values in? Are they all integers?

3. Do you know for sure each line will contain the same number of values? If not, consider using an array type with flexible size.

Hope this helps as a first nudge ;)

Stefan

There is a C++ library which handles this kind of thing very elegantly at boost (see http://www.boost.org/libs/tokenizer/ ), but I must confess that I'd probably show my failure to shrug off C and use strtok for this, which is supposed to be bad form even amongst C programmers.

If you want to be evil, and you are *not* submitting this to be judged by the powers that be, you can use strtok thus:
--------8<--------
#include <iostream>
#include <string>
#include <memory>

void process(const std::string& str);

int main()
{
      process("a: 12,0.7,12,12.5");
      process("b: text, 23, 24, 10");
}

void process(const std::string& str)
{
      std::string str_copy = str;
      std::cout << "Processing \"" << str << "\":\n";

      // Ugh... poking into a std::string... this is really evil... and may not be portable
      char *p = const_cast<char*>(str_copy.c_str());

      const char seps[] = " ,";
      for (const char *cptr = strtok(p,seps);cptr;cptr = strtok(0,seps)) {
            std::string str = cptr;
            std::cout << "\t\"" << str << "\"\n";
      }
      std::cout << '\n';
}
--------8<--------

I'm going to be flamed for suggesting this :-)

Shame on you, rstaveley. The hell will open and get your nasty soul.

Why not simply parse the string:

vector<string> tokens;
int pos=0;
for (int i = 0; i <= str.length(); i++)
{
     switch(str.c_str()[i])
     {
     case ':':  case ' ':  case ',':  case '\0':
         if (i > pos)
            tokens.pushback(str.substr(pos, i-pos));
         pos=i+1;
         break;
     }
}

Ok, i'll get flamed also.

Regards, Alex

Why not use some inline asm?

asm volatile ("cmp %2, %%eax\n\t"
              "bz .found\n\t"
              "cmp %3, %%eax\n\t"
              "bz .found\n\t"
              "cmp %4, %%eax\n\t"
              "bnz .goaway\n"
              ".found: mov %5,%0\n"
              ".goaway:"
                : "=g" (delim_pos)
                : "a" (str.c_str()[i]), "i" (':'), "i" (' '), "i" (','), "g" (i));

*ouch*

Nooooooo, I was just fantasizing. Using C strings is the lesser evil ;-)
Stefan

Using boost is undoubtedly the politically correct approach, but tokenising never really gets all that clean-looking in the real world. Here's my attempt at doing it with find_first_of in comparison with boost::tokenizer. Neither of them look very pretty. Alex's approach is more legible. Stefan should join me in pergatory :-)

--------8<--------
#include <iostream>
#include <boost/tokenizer.hpp>
#include <vector>
#include <string>

void process_std(const std::string& str),process_boost(const std::string& str);

int main()
{
      process_std("a: 12,0.7,12,12.5");
      process_std("b: text, 23, 24, 10");

      process_boost("a: 12,0.7,12,12.5");
      process_boost("b: text, 23, 24, 10");
}

// Using the standard library - not great-looking
void process_std(const std::string& str)
{
      std::cout << "Tokenizing \"" << str << "\"\n";
      std::vector<std::string> tokens;
      using std::string::size_type;
      size_type start_pos = 0,end_pos;
      do {
            end_pos = str.find_first_of(": ,",start_pos);
            std::string substr(str,start_pos,end_pos-start_pos);
            if (substr.size()) {
                  std::cout << "Token \"" << substr << "\"\n";
                  tokens.push_back(substr);
            }
            start_pos = end_pos+1;
      } while (end_pos != std::string::npos);
      std::cout << '\n';
}

// Using boost's tokenizer - a bit nicer
void process_boost(const std::string& str)
{
      std::cout << "Tokenizing \"" << str << "\"\n";
      std::vector<std::string> tokens;
      typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
      boost::char_separator<char> sep(": ,");
      tokenizer tok(str,sep);
      typedef tokenizer::iterator Itr;
      for (Itr itr = tok.begin();itr != tok.end();++itr) {
            std::string substr = *itr;
            std::cout << "Token \"" << substr << "\"\n";
            tokens.push_back(substr);
      }
      std::cout << '\n';
}
--------8<--------

if that is assembler, i'am a pretty girl in my mid-twenties ;-)

Regards, Alex

As far as i know purgatory isn't infinite. So, with your first solution you still could  rise to heaven (after 5 million years, or so...).

However, that boost thing is worse and you won't get any mercy for this (it has a triple more statements than tokens!!!).

Regards, Alex

I confess that I've yet to get much joy out of Boost. Heaven can wait.

itsmeandnobodyelse,
> if that is assembler, i'am a pretty girl in my mid-twenties ;-)
that's gcc extended asm, so put on those high heels :-)

Stefan

Stefan,  size 11 and high red heels!!

sarahsthss, thanks for the points, but you should have honoured others too by splitting the points.

But maybe it's too hot there where they are to think of points... ;-)

Regards, Alex