Почему я не могу преобразовать этот возврат регулярного выражения в строку в целое число или прямо в целое число? (С++)

Ваша проблема в этой строке:

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

Вы не можете передать временное значение в качестве строки темы совпадения с регулярным выражением, потому что содержимое строки все еще должно быть в наличии, когда вы запрашиваете результаты совпадения. Результат (string)matches[1] уничтожается в конце текущего полного выражения (т.е. в следующей точке с запятой); когда вы добираетесь до запроса time0[1] в следующей строке, совпадение time0 относится к строке, которой больше не существует, что является неопределенным поведением.

Давайте разберемся на примере: вот что происходит в моей среде VS2012:

Ошибка в строке buffer << time0[1];.

В этой строке я фактически вызываю std::ostream:: operator‹‹, передав ему результат std ::match_results::operator[], который является ссылкой на объект std::sub_match.

Этот объект можно преобразовать в string_type (псевдоним типа basic_string, используемый с символами, на которые ссылается тип итератора), поскольку для него определено преобразование.

Итак, я что-то делаю:

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

В этот момент строка должна существовать и быть действительной. Быстрая проверка с помощью отладчика показывает, что чего-то не хватает:

поле "first", которое является итератором начала совпадения, отсутствует. Этот итератор является двунаправленным итератором, указывающим на вашу строку: поэтому что-то должно произошло с вашей строкой.

Если вы посмотрите, как (опять же, в среде VS2012) определяется функция regex_match:

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));
    }

ясно, что берется ссылка на const basic_string, он НЕ копирует ее каким-либо образом и не возится с ней.

Вы можете имитировать такое же поведение с помощью следующего кода:

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
  ....
}

и попробуйте сами. На моей машине это точно не сработает, а даже если и сработало, то можно быть уверенным, что рано или поздно оно вас разочарует.

Так вот почему у вас странные результаты. Простое решение может состоять в том, чтобы просто расширить область видимости вашей строки:

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;
}

Вы уверены, что ваше регулярное выражение соответствует тому, что вы хотите?

например, регулярное выражение "^(.+)-(.+)-(.+)$" будет соответствовать всей строке в вашем примере входного файла, например, оно соответствует вся строка:

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

потому что части .+ будут соответствовать чему угодно (включая - символы и т. д.).

Итак, если вы хотите сопоставить только 1996-09-04, вы можете попробовать регулярное выражение \d{4}-\d{1,2}-\d{1,2} или что-то в этом роде. вы можете попробовать регулярное выражение в этом онлайн-инструмент для регулярных выражений

Кроме того, другое регулярное выражение ^(.+),(.+),.+,.+,(.+),.+,.+$ выглядит подозрительно для меня, действительно ли вы хотите сопоставить любую строку, содержащую 6 запятых и по крайней мере 1 символ между ними? Помните, что . — очень жадное регулярное выражение.

ОБНОВЛЕНИЕ: я действительно думаю, что ваше первое регулярное выражение слишком жадное, см. пример здесь

int atoi (const char * str);

Попробуйте использовать массив символов вместо string.

Я думаю, что здесь можно применить принцип KISS, чтобы получить лучшее решение, чем использование регулярных выражений. Просто прочитайте в каждом поле, используя istream. Regex — это излишество ИМХО.

#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;
}

Черт, iostream тоже перебор. Вот решение C с использованием 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;
}

Видите, насколько это короче и понятнее? Спецификатор формата scanf может легко фиксировать формат ваших данных, и его гораздо проще использовать, чем регулярное выражение. Обратите внимание, что вам не нужно разбивать данные на токены, а затем анализировать каждый токен. Вы сразу же получаете проанализированный числовой вывод.