Задача со строками и файлами

[Broken_Dreams]

С++
Задан текстовый файл Input.txt, состоящий из слов.
Разделителями между словами являются некоторое множество знаков препинания.
Удалить из каждой строки, начиная со второй, слова, которые встречаются в первой строке и записать результат
в новый файл Output.txt.Упорядочить слова в полученных строках по возрастанию количества цифр в словах,
результат сортировки записать в файл Out_sort.txt.

Нужна помощь, уже долго голову ломаю, так ничего и не вышло.

Файл вводить самому с консоли.

[digitalis]

Нужна помощь - урезать этот файл? Так, как говорится, файл - в студию!
Или всё-таки написать прогу, которая это делает? На всех существующих в мире языках программирования?
--------------------
Ну вот - совсем другое дело.

[Пётр Седов]

#include <string.h>
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <fstream>

using namespace std;

bool is_separator(char elem) {
  return (elem == ' ') || (elem == ',') || (elem == '.');
}

bool is_digit(char elem) {
  return ('0' <= elem) && (elem <= '9');
}

enum part_type_t {_part_type_word, _part_type_separators};

// часть текста
struct part_t {
  part_type_t type;
  const char* elems; // не завершается нулевым элементом ('\0')
  int len;
  int digits_count;
};

// разбивает текст на части
vector<part_t> get_parts(const char* text, bool need_separators) {
  vector<part_t> parts;
  int pos = 0;
  for (;;) {
    // сканируем разделители
    int start = pos;
    while (is_separator(text[pos])) {pos++;}
    if (need_separators && (pos > start)) {
      part_t p;
      p.type = _part_type_separators;
      p.elems = text + start;
      p.len = pos - start;
      p.digits_count = -1; // нет определённого значения
      parts.push_back(p);
    }
    if (text[pos] == '\0') {break;} // если дошли до конца текста
    // сканируем слово
    start = pos;
    int digits_count = 0;
    do {
      if (is_digit(text[pos])) {digits_count++;}
      pos++;
    } while ((text[pos] != '\0') && !is_separator(text[pos]));
    part_t p;
    p.type = _part_type_word;
    p.elems = text + start;
    p.len = pos - start;
    p.digits_count = digits_count;
    parts.push_back(p);
  }
  return parts;
}

bool has_part(const vector<part_t>* parts, const part_t* part) {
  for (int i = 0; i < parts->size(); i++) {
    const part_t* p = &(*parts)[i];
    if ((p->len == part->len) && (memcmp(p->elems, part->elems, part->len) == 0)) {
      return true;
    }
  }
  return false;
}

ostream& operator<<(ostream& stream, const part_t& part) {
  stream.write(part.elems, part.len);
  return stream;
}

int main() {
  ifstream input_file("Input.txt");
  if (input_file.fail()) {
    cerr << "Cannot open file." << endl;
    return 1;
  }
  ofstream output_file_1("Output.txt");
  ofstream output_file_2("Out_sort.txt");
  if (output_file_1.fail() || output_file_2.fail()) {
    cerr << "Cannot create file." << endl;
    return 1;
  }
  string first_line;
  getline(input_file, first_line);
  vector<part_t> discard_words = get_parts(first_line.c_str(), /*need_separators:*/false);
  while (!input_file.eof()) {
    string line;
    getline(input_file, line);
    vector<part_t> parts = get_parts(line.c_str(), /*need_separators:*/true);
    // фильтруем слова
    int i = 0;
    while (i < parts.size()) {
      if ((parts[i].type == _part_type_word) && has_part(&discard_words, &parts[i])) {
        parts.erase(parts.begin() + i);
      } else {
        output_file_1 << parts[i];
        i++;
      }
    }
    output_file_1 << '\n';

    // сортируем оставшиеся слова
    for (int i = 0; i < parts.size(); i++) {
      if (parts[i].type == _part_type_word) {
        // ищем «минимальное» слово, начиная с i-го
        int min = i;
        for (int k = i + 1; k < parts.size(); k++) {
          if ((parts[k].type == _part_type_word) && (parts[k].digits_count < parts[min].digits_count)) {
            min = k;
          }
        }
        // ставим «минимальное» слово в позицию i
        if (i != min) {
          swap(parts[i], parts[min]);
        }
      }
      output_file_2 << parts[i];
    }
    output_file_2 << '\n';
  }
  return 0;
}

Файл Input.txt:

the, me
step 333 aside, 22 let 1 me explain
the name of the 333 game 22 is 1 pain

Файл Output.txt:

step 333 aside, 22 let 1  explain
 name of  333 game 22 is 1 pain

Файл Out_sort.txt:

step aside let, explain 1 22  333
 name of  game is pain 1 22 333

Сообщение от Broken_Dreams

Файл вводить самому с консоли.

Я не вводил файл Input.txt в консоли, я создал его в текстовом редакторе.

[Broken_Dreams]

Спасибо большое!

Вроде со всем разобрался, разве что вопросы с

ostream& operator<<(ostream& stream, const part_t& part) {
  stream.write(part.elems, part.len);
  return stream;
}

Для чего используется & с ostream?

[Пётр Седов]

Сообщение от Broken_Dreams

Для чего используется & с ostream?

ostream& -- ссылка на объект типа ostream.
const part_t& -- const-ссылка на объект типа part_t (в данном случае «const» значит «read only»).
Ссылки -- это аналог указателей, с некоторыми отличиями:
1. Ссылка в момент создания обязательно связывается с каким-нибудь объектом, и за время своей жизни ссылается только на этот объект, это никак легально не поменять. Указатель необязательно инициализировать в момент создания, и за время своей жизни он может указывать на разные объекты.
2. Синтаксические различия:

pointer->method();
reference.method();

3. Указатель может легально указывать «вникуда» (NULL, nullptr), ссылка -- нет.
4. const-ссылка продлевает время жизни временного объекта:

const string& file_name = add_extension("Input"); // результат вызова функции -- временный неименованный объект
// временный объект до сих пор существует
// а без const-ссылки он был бы уничтожен сразу же

----------------
Например, стандартные функции std::getline и std::swap принимают объекты через ссылки, но я так не люблю, я в таких случаях использую указатели. Потому что ссылки реально нужны для:
* Конструктор копирования.
* Перегрузка операторов.
* Ловля исключений (exceptions).

Сообщение от Broken_Dreams

ostream& operator<<(ostream& stream, const part_t& part) {
  stream.write(part.elems, part.len);
  return stream;
}

Так обычно делают, когда используют iostreams: перегрузка оператора << для своего типа. Но можно и обычную функцию сделать:

void write(ostream* stream, const part_t* part) {
  stream->write(part->elems, part->len);
}

Используем так:

write(&output_file_1, &parts[i]); // в данном случае, & -- это получение указателя на объект, а не ссылка

А можно вообще без функции:

output_file_1.write(parts[i].elems, parts[i].len);