groupscreator

#include <iostream>
#include <map>
#include <string>
#include <vector>
#include <fstream>
#include <algorithm>
#include <iterator>

using namespace std;

class GroupsCreator
{
    virtual multimap<int, string> GetGroupMap() = 0;
};

class Student
{
    int group;
    string number;

public:

    Student() : group(0), number("") {}

    Student(const int _group, const string& _number) : group(_group), number(_number) {}

    int GetGroup() const { return group; }
    string GetNumber() const { return number; }

    bool operator < (const Student& student) const
    {
        return number < student.number;
    }

    bool operator != (const Student& student) const
    {
        return group != student.group && number != student.number;
    }

    friend ostream& operator << (ostream& stream, const Student& student)
    {
        stream << student.group << " " << student.number;

        return stream;
    }

    friend istream& operator >> (istream& stream, Student& student)
    {
        stream >> student.number >> student.group;

        return stream;
    }
};

class Exam : GroupsCreator
{
    string name;
    vector<Student> students;

public:

    Exam(const string& filename)
    {
        ifstream(filename, ios::in) >> *this;
    }

    string GetName() const { return name; }

    void SetName(const string& _name) { name = _name; }

    multimap<int, string> GetGroupMap()
    {
        multimap<int, string> group_map;

        transform(students.begin(), students.end(), inserter(group_map, group_map.begin()), [](Student& student){
            return pair<int, string>(student.GetGroup(), student.GetNumber());
        });

        return group_map;
    }

    static void out(ostream& stream, const multimap<int, string>& group_map, const int group)
    {
        multimap<int, string> in_group_map;

        copy_if(group_map.begin(), group_map.end(), inserter(in_group_map, in_group_map.begin()), [&group](pair<int, string> key_value) {
            return key_value.first == group;
        });

        vector<string> data;

        transform(in_group_map.begin(), in_group_map.end(), back_inserter(data), [](pair<int, string> key_value){ return key_value.first + " " + key_value.second; });

        copy(data.begin(), data.end(), ostream_iterator<string>(stream, "\n"));
    }

    bool operator < (const Exam& exam) const
    {
        return name < exam.name;
    }

    friend ostream& operator << (ostream& stream, const Exam& exam)
    {
        stream << exam.name << endl;

        //copy(exam.students.begin(), exam.students.end(), ostream_iterator<Student>(stream, "\n"));

        return stream;
    }

    friend istream& operator >> (istream& stream, Exam& exam)
    {
        stream >> exam.name;

        //copy(istream_iterator<Student>(stream), istream_iterator<Student>(), back_inserter(exam.students));

        return stream;
    }
};

int main()
{
    Exam exam("exam.txt");

    //cout << exam << endl;

    auto group_map = exam.GetGroupMap();

    exam.out(cout, group_map, 1);

    system("pause");
    return 0;
}