Запись в файл вектора

struct game {...};
// для структуры game пишем операторы << и >>
std::ostream& operator << (std::ostream& out, const game& game)
{
  ...
  return out;
}
std::istream& operator >> (std::istream& in, game& game)
{
  ...
  return in;
}
 
 
в коде:
 
{
  std::vector<game> games;
  ... заполняем вектор
  std::ofstream ofs("data.txt"); // нужные флажочки, бинарный не бинарный и т.п.
  для каждого элемента вектора позвать
  ofs << games[i];
}
 
{
  std::vector<game> games;
  std::ifstream ifs("data.txt"); // нужные флажочки, бинарный не бинарный и т.п.
  пока не дошли до конца стрима, вызываем оператор >>
  while (ifs) // ну или тут какая-то другая проверка должна быть на конец стрима
  {
     game g;
     ifs >> g;
     games.push_back(g);
  }
}
 
можно пользовать спец алгоритмы и не писать циклы вручную,
но с циклами вам будет наверно понятнее.

ofs<<games[i];

std::copy(v.begin(), v.end(), std::ostream_iterator<type> (std::cout, " "));

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;
 
struct game{
    game(int d,string o):data(d),opon(o){}
    int data;
    string opon;
    friend ostream& operator << (std::ostream& out, const game& game){
        out<<game.data<<" "<<game.opon<<endl;
    return out;
    }
    friend istream& operator >> (std::istream& in, game& game){
    int dat;
    string oppon;
    in>>dat;
    in>>oppon;
    game.data=dat;
    game.opon=oppon;
        return in;
    }
 
};
 
int main()
{
 
    vector<game>gamelist;
    int s=2;
    int k=3;
    int n=0;
    string ss="GYY";
    string kk="MADI";
    game g1(s,ss);
    game g2(k,kk);
    gamelist.push_back(g1);
    gamelist.push_back(g2);
    n=gamelist.size();
    ofstream ofs("c://test.txt",ios::binary|ios::out);
    for(int i=0;i<n;n++){
        ofs<<gamelist[i];
    }
 
    ifstream ifs("c://data.txt",ios::binary|ios::in);
  while (ifs)
  {
     game g1(s,ss);
     ifs >> g1;
        cout<<g1;
     gamelist.push_back(g1);
  }
 
}

#include <iostream>
#include <string>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <clocale>
#include <stdexcept>
#include <fstream>
#include <vector>
namespace ba = boost::archive;
 
struct Game
{
    int data;
    std::string opponent;
    int countplayers;
    template<typename Archive>
    void serialize(Archive& ar, unsigned const version)
    {
        ar & data;
        ar & opponent;
        ar & countplayers;
    }
};
 
std::ostream& operator<<(std::ostream& ost, Game const& g)
{
    return ost << g.data << '\n' << g.opponent << '\n' << g.countplayers;
}
 
int main ()
{
    setlocale(LC_ALL, "rus");
    try
    {
        std::vector<Game> v{{1, "op1", 10}, {2, "op2", 20}, {3, "op3", 30}}, vres;
        std::string sfilename("out.bin");
        std::fstream fs(sfilename.c_str(), std::ios::binary | std::ios::out);
        if(!fs.is_open())
            throw std::runtime_error("Unable to open output file");
        ba::binary_oarchive boa(fs);
        boa << v;
        fs.clear();
        fs.close();
        fs.open(sfilename.c_str(), std::ios::binary | std::ios::in);
        if(!fs.is_open())
            throw std::runtime_error("Unable to open input file");
        ba::binary_iarchive bia(fs);
        bia >> vres;
        fs.close();
        for(auto const& val : vres)
            std::cout << val << "\n\n";
    }
    catch(std::exception const& e)
    {
        std::cerr << "Exception: " << e.what() << std::endl;
    }
    return 0;
}

#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/vector.hpp>

namespace ba = boost::archive;