Поиск конца файла при чтении из него

Ваше условие в цикле while неверно. ios::eof() не предсказывает; он будет установлен только после того, как поток попытается (внутренне) прочитать за пределами конца файла. Вы должны проверять после каждого ввода
.

Классический способ обработки вашего случая состоял бы в том, чтобы определить функцию >> для GTable в соответствии с строками:

std::istream&
operator>>( std::istream& source, GTable& dest )
{
    std::string line;
    while ( std::getline( source, line ) && line.empty() ) {
    }
    if ( source ) {
        std::istringstream tmp( line );
        std::string name;
        int count;
        if ( !(tmp >> name >> count) ) {
            source.setstate( std::ios::failbit );
        } else {
            std::vector< char > adjactentOnes;
            char ch;
            while ( tmp >> ch ) {
                adjactentOnes.push_back( ch );
            }
            if ( !tmp.eof() || adjactentOnes.size() != count ) {
                source.setstate( std::ios::failbit );
            } else {
                dest.Name = name;
                dest.Out = count;
                for ( int i = 0; i < count; ++ i ) {
                    dest.AdjacentOnes.addFront( adjactentOnes[ i ] );
                }
            }
        }
    }
    return source;
}

(Это было написано довольно поспешно. В реальном коде я бы почти наверняка выделил внутренний цикл в отдельную функцию.)

Обратите внимание, что:

• Читаем построчно, чтобы проверить формат (и разрешить повторную синхронизацию в случае ошибки).

• Ставим failbit в исходном потоке на случай ошибки ввода.

• Мы пропускаем пустые строки (поскольку ваш ввод явно их содержит).

• Мы не изменяем целевой элемент, пока не убедимся, что ввод правильный.

У нас есть это, легко перебрать все элементы:

int slot = 0;
while ( slot < GTable.size() && fin >> GTable[ slot ] ) {
    ++ slot;
}
if ( slot != GTable.size )
    //  ... error ...

РЕДАКТИРОВАТЬ:

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

РЕДАКТИРОВАТЬ 2:

Учитывая количество неверных ответов на этот вопрос, я хотел бы подчеркнуть:

• Любое использование fin.eof() до того, как известно, что ввод не пройден, является неправильным.

• Любое использование fin.good(), точка, неправильно.

• Любое использование одного из значений, считанных до проверки успешного ввода, является неправильным. (Это не предотвращает такие вещи, как fin >> a >> b, если ни a, ни b не используются до проверки успеха.)

• Любая попытка прочитать Gtable[slot] без проверки того, что slot находится в границах, неверна.

Что касается eof() и good():

Базовый класс istream и ostream определяет три бита ошибки: failbit, badbit и eofbit. Важно понимать, когда они установлены: badbit устанавливается в случае неисправимой аппаратной ошибки (фактически, практически никогда, так как большинство реализаций не могут или не обнаруживают такие ошибки); а failbit устанавливается в любом другом случае сбоя ввода, будь то отсутствие доступных данных (конец файла), или ошибка формата ("abc" при вводе int и т.п.). eofbit устанавливается в любое время, когда streambuf возвращает EOF, независимо от того, приводит ли это к сбою ввода или нет! Таким образом, если вы читаете int, а поток содержит "123" без завершающих пробелов или новой строки, будет установлено eofbit (поскольку поток должен читать вперед, чтобы знать, где заканчивается int); если поток содержит "123\n", eofbit не будет установлен. Однако в обоих случаях ввод выполняется успешно, и failbit не будет установлено.

Для чтения этих битов есть следующие функции (в виде кода, так как иначе я не знаю, как получить таблицу):

eof():   returns eofbit
bad():   returns badbit
fail():  returns failbit || badbit
good():  returns !failbit && !badbit && !eofbit

operator!():      returns fail()
operator void*(): returns fail() ? NULL : this
    (typically---all that's guaranteed is that !fail() returns non-null.)

Учитывая это: первая проверка всегда должна быть fail() или одной из operator (которые основаны на fail). Как только fail() возвращает значение true, мы можем использовать другие функции, чтобы определить, почему:

if ( fin.bad() ) {
    //  Serious problem, disk read error or such.
} else if ( fin.eof() ) {
    //  End of file: there was no data there to read.
} else {
    //  Formatting error: something like "abc" for an int
}

Практически говоря, любое другое использование является ошибкой (и любое использование good() является ошибкой, не спрашивайте меня, почему эта функция существует).

Немного более медленный, но более чистый подход:

void graph::fillTable()
{
  ifstream fin("data.txt");
  char X;
  int slot=0;

  std::string line;

  while(std::getline(fin, line))
  {
    if (line.empty()) // skip empty lines
      continue;

    std::istringstream sin(line);
    if (sin >> Gtable[slot].Name >> Gtable[slot].Out && Gtable[slot].Out > 0)
    {
      std::cout << Gtable[slot].Name << std::endl;
      for(int i = 0; i < Gtable[slot].Out; ++i)
      {
        if (sin >> X)
        {
          std::cout << X << std::endl;
          Gtable[slot].AdjacentOnes.addFront(X);
        }
      }
      slot++;
    }
  }
}

Если у вас все еще есть проблемы, это не с чтением файла...

Файл не выйдет из строя до тех пор, пока вы не начнете читать с конца файла. Этого не произойдет до строки fin>>Gtable[slot].Name;. Так как ваша проверка предшествует этому, good все равно может вернуть true.

Одним из решений было бы добавить дополнительные проверки на сбой и выйти из цикла, если это так.

fin>>Gtable[slot].Name;
fin>>Gtable[slot].Out;
if(!fin) break;

Это по-прежнему не очень хорошо обрабатывает ошибки форматирования во входном файле; для этого вы должны читать построчно, как указано в некоторых других ответах.

Попробуйте переместить первые два чтения в условие while:

// assuming Gtable has at least size of 1

while( fin>>Gtable[slot].Name && fin>>Gtable[slot].Out ) {
    cout<<Gtable[slot].Name<<endl;
    for(int i=0; i<=Gtable[slot].Out-1;i++) {
        fin>>X;
        cout<<X<<endl;
        Gtable[slot].AdjacentOnes.addFront(X);
    }
  slot++;

  //EDIT:

  if (slot == table_size) break;
}

Редактировать: согласно комментарию Джеймса Канзе, вы берете адрес за конец массива Gtable, что вызывает segfault. Вы можете передать размер Gtable в качестве аргумента вашей функции fillTable() (например, void fillTable(int table_size)) и проверить, что slot находится в границах перед каждым чтением.

*Отредактировано в ответ на комментарий Джеймса — теперь в коде используется проверка good() вместо проверки !eof(), что позволит отлавливать большинство ошибок. Я также добавил проверку is_open(), чтобы убедиться, что поток связан с файлом.*

Как правило, вы должны попытаться структурировать чтение файла в цикле следующим образом:

ifstream fin("file.txt");
char a = '\0';
int b = 0;
char c = '\0';

if (!fin.is_open())
    return 1; // Failed to open file.

// Do an initial read. You have to attempt at least one read before you can
// reliably check for EOF.
fin >> a;

// Read until EOF
while (fin.good())
{
    // Read the integer
    fin >> b;

    // Read the remaining characters (I'm just storing them in c in this example)
    for (int i = 0; i < b; i++)
        fin >> c;

    // Begin to read the next line. Note that this will be the point at which
    // fin will reach EOF. Since it is the last statement in the loop, the
    // file stream check is done straight after and the loop is exited.
    // Also note that if the file is empty, the loop will never be entered.
    fin >> a;
}

fin.close();

Это решение желательно (на мой взгляд), потому что оно не полагается на добавление случайных break внутри цикла, а условием цикла является простая проверка good(). Это облегчает понимание кода.