Why can I not convert this regex return to a string to an integer or straight to an integer? (C++)

Question 1

Your problem is in this line:

regex_match((string)matches[1], time0, exp_time);

You can't pass a temporary as the subject string of a regex match, because the string contents have to still be around when you query the match results. The result of (string)matches[1] is destroyed at the end of the current full expression (i.e. at the next semicolon); when you get around to querying time0[1] on the next line, the time0 match is referring to a string that doesn't exist any more, which is undefined behaviour.

Question 2

Let's understand it with an example: this is what's happening in my VS2012 environment:

enter image description here

There's an error in the buffer << time0[1]; line.

In that line I'm actually calling the std::ostream::operator<< by passing it the result of the std::match_results::operator[] which is a std::sub_match object reference.

That object can be converted to a string_type (an alias of the basic_string type being used with the characters being referred by the iterator type) since there's a conversion defined for it.

So I'm doing something:

buffer << (string with the contents of sub_match object).

At that point the string must exist and be valid. A rapid inspection with the debugger shows that something's missing:

enter image description here

the "first" field, which is an iterator to the beginning of the match, is missing. That iterator is a bidirectional iterator pointing to your string: so something must have happened to your string.

If you take a look at how (again, in a VS2012 environment) the regex_match function is defined:

template<class _StTraits,
    class _StAlloc,
    class _Alloc,
    class _Elem,
    class _RxTraits> inline
    bool regex_match(
        const basic_string<_Elem, _StTraits, _StAlloc>& _Str, <--- take a look here
        match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::
            const_iterator, _Alloc>& _Matches,
        const basic_regex<_Elem, _RxTraits>& _Re,
        regex_constants::match_flag_type _Flgs =
            regex_constants::match_default)
    {   // try to match regular expression to target text
    return (_Regex_match(_Str.begin(), _Str.end(),
        &_Matches, _Re, _Flgs, true));
    }

it is clear that is taking a reference to a const basic_string, it's NOT copying it somehow nor r-value fiddling with it.

You can simulate the same behavior with the following code:

std::string::iterator myFirstElement; // every random-access iterator is a bidirectional iterator

void takeAReference(std::string& mystring)
{
  // Here mystring is valid!
  myFirstElement = mystring.begin();
}


int main(int argc, char* argv[])
{

  takeAReference(string("hello dear"));

  // Iterator is now NO MORE VALID! Try to inspect it / use it
  ....
}

and try it for yourself. On my machine this won't definitely work and even if it worked you can be sure that sooner or later it will disappoint you.

So that's the reason why you're having weird results. A simple solution could be to just extend your string's scope of visibility:

int main(int argc, char* argv[])
{
  regex exp("^(.+),(.+),.+,.+,(.+),.+,.+$");
  regex exp_time("^(.+)-(.+)-(.+)");
  smatch matches;
  smatch time0;
  string line;
  ifstream infile("testfile.txt");
  string last_match;
  stringstream buffer;
  string str;


  int i = 0;

  if (infile.is_open())
  {
    while (getline(infile, line))
    {

      regex_match(line, matches, exp);

      std::string first_date = (string)matches[1]; <--!!

      regex_match(first_date, time0, exp_time);

      buffer << time0[1];
      str = buffer.str();

      str = time0[1].str();
      str.append("\0");

      cout << atoi(str.c_str()) << " " << time0[1] << '\n';

      last_match = matches[2];
      buffer.str(string());
      i++;
    }
    infile.close();
  }

  return 0;
}

Question 3

Are you sure your regex is matching what you want?

for example the regex "^(.+)-(.+)-(.+)$" would match the whole line in your example input file, like for example it matches the whole line:

1996-09-04,19.00,19.25,18.62,18.87,528000,0.79

because the .+ parts will just match anything (incl ,- chars etc.).

So if you want to match just 1996-09-04 then you could try the regex \d{4}-\d{1,2}-\d{1,2} or something like that. you can try out the regex in this online regex-tool

Also the other regex ^(.+),(.+),.+,.+,(.+),.+,.+$ looks suspicious to me, do really you want to match any line that has 6 commas with at least 1 char between them? Remember that the . is a very greedy regex.

UPDATE: I really think your first regex is too greedy, see example here

Question 4

int atoi (const char * str);

Try using a char array instead of a string.

Question 5

I think the KISS principle can be applied here to get a better solution than using regex. Simply read in each field using istream. Regex is overkill IMHO.

#include <iostream>
#include <string>
#include <fstream>
using namespace std;

struct date_t
{
  int year, month, day;
};

struct data_t
{
  date_t date;
  float f1, f2, f3, f4;
  int i;
  float f5;
};

istream & operator>>(istream & in, date_t &date)
{
  char d1, d2;  // dummy chars for the hyphens
  return in >> date.year >> d1 >> date.month >> d2 >> date.day;
}

istream & operator>>(istream & in, data_t &data)
{
  char d1, d2, d3, d4, d5, d6;  // dummy chars for the commas
  return in >> data.date >> d1 >> data.f1 >> d2 >> data.f2 >> d3
    >> data.f3 >> d4 >> data.f4 >> d5 >> data.i >> d6 >> data.f5;
}

ostream & operator<<(ostream & out, const date_t &date)
{
  return out << date.year << '-' << date.month << '-' << date.day;
}

ostream & operator<<(ostream & out, const data_t &data)
{
  return out << data.date << ',' << data.f1 << ',' << data.f2 << ','
    << data.f3 << ',' << data.f4 << ',' << data.i << ',' << data.f5;
}


int main(int argc, char* argv[])
{
  ifstream infile(argv[1]);

  data_t data;
  while(infile >> data) {
    cout << "Here is the data: " << data << endl;
  }

  infile.close();

  return 0;
}

Heck, iostream is kind of overkill too. Here is a C solution using fscanf.

#include <stdio.h>
#include <stdio.h>

struct date_t
{
  int year, month, day;
};

struct data_t
{
  struct date_t date;
  float f1, f2, f3, f4;
  int i;
  float f5;
};

int read_data(FILE *fid, struct data_t *data)
{
  return fscanf(fid, "%d-%d-%d,%f,%f,%f,%f,%d,%f",
      &(data->date.year), &(data->date.month), &(data->date.day),
      &(data->f1), &(data->f2), &(data->f3), &(data->f4), &(data->i), &(data->f5));
}

int main(int argc, char* argv[])
{
  FILE *fp = fopen(argv[1], "rt");

  struct data_t data;

  while(read_data(fp, &data) == 9) {
    printf("Here is your data: %d-%02d-%02d,%.2f,%.2f,%.2f,%.2f,%d,%.2f\n",
      data.date.year, data.date.month, data.date.day,
      data.f1, data.f2, data.f3, data.f4, data.i, data.f5);
  }

  return 0;
}

See how much shorter and easy to understand that is? The scanf format specifier can easily capture the format of your data, and it's much simpler to use than regex. Note that you don't have to split the data into tokens, and then parse each token. You get the parsed, numeric output right away.