Рисование фигуры из точек в файле

void drawing(list<point> &l)

#include <iostream>
#include <fstream>
#include <list>
 
using namespace std;
 
struct point
{
    int x,y;
    point() : x(0),y(0) {}
    point(int _x, int _y) : x(_x),y(_y) {} 
};
 
class write_file
{
    int x,y;
    ofstream fout;
    void func_x(int _x)
    {
        for (;x!=_x;x++) fout <<" ";
    }
    void func_y(int _y)
    {
        for (;y!=_y;y++) fout <<"\n";
        x=0;
    }
public:
    write_file() : x(0),y(0) {}
    void drawing(list<point> &l)
    {
        fout.open("write_file.txt");
        list<point> :: iterator p = l.begin();
        while (p != l.end())
        {
            if (y != p->y) func_y(p->y);
            if (x != p->x) func_x(p->x);
            fout<<"*";
            x++;
            p++;
        }
        fout.close();
    }
};

#include <fstream>
#include <algorithm>
#include <string>
#include <random>
#include <vector>
#include <iterator>
 
struct Point
{
    int x;
    int y;
};
 
std::istream& operator>>(std::istream& stream, Point& point)
{
    stream >> point.x >> point.y;
    return stream;
}
 
int main()
{
    const std::string inFileName = "inFile";
    const std::string outFileName = "outFile";
    const bool generateInFile = true;
    const int screenSize = 20;
 
    if (generateInFile)
    {
        const int countPoint = static_cast<int>(screenSize * screenSize / 1.8);
 
        std::ofstream prepareDataFile(inFileName);
 
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dis(0, screenSize - 1);
 
        std::generate_n(std::ostream_iterator<int>(prepareDataFile, " "), countPoint * 2, [&dis,&gen]()
        {   return dis(gen);});
    }
 
    std::ifstream inFile(inFileName);
    std::ofstream outFile(outFileName);
    if (!inFile || !outFile)
    {
        return -1;
    }
    std::vector<Point> inFileData = { std::istream_iterator<Point>(inFile), std::istream_iterator<Point>() };
    std::vector<std::string> screen { screenSize, std::string(screenSize, ' ') };
    for (const auto& point : inFileData)
    {
        screen[point.x][point.y] = '*';
    }
    std::copy(screen.begin(), screen.end(), std::ostream_iterator<std::string>(outFile, "\n"));
    return 0;
}

    std::vector<Point> inFileData = { std::istream_iterator<Point>(inFile), std::istream_iterator<Point>() };// прочитали входной файл. файл содержит - (x y x y ....)
    std::vector<std::string> screen { screenSize, std::string(screenSize, ' ') };// прикол тут. Создали вектор строк размером screenSize*screenSize заполненных пробелами.
    for (const auto& point : inFileData)
    {
        screen[point.x][point.y] = '*';// на каждый поинт из входного файла заменяем в векторе строк соответствующий элемент.
    }
    std::copy(screen.begin(), screen.end(), std::ostream_iterator<std::string>(outFile, "\n"));// выводим в файл наш подготовленный вектор строк, по одной строке на строку :)

//написать программу которая рисует фигуру в файле txt из множества точек x,y записанных
//в другом файле.
///////////////////////////////////////////////////////////////////////////////
#include <fstream>
#include <iostream>
#include <map>
#include <string>
#include <utility>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                         T_str;
typedef std::multimap   < int,  int     >   T_point_of_line_ind;
///////////////////////////////////////////////////////////////////////////////
class   T_points
{
    //-------------------------------------------------------------------------
    static  const   char    SPACE_SYMB      =   ' ';
    static  const   char    ASTERISK_SYMB   =   '*';
    //-------------------------------------------------------------------------
    T_point_of_line_ind     point_of_line_ind_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    friend
    std::istream    &   operator>>
        (
            std::istream    &   istr,
            T_points        &   points
        )
    {
        int     L   {};
        int     R   {};
 
        while   (
                        istr    >>  L
                    &&  istr    >>  R
                )
        {
            points.point_of_line_ind_.insert
                (
                    std::make_pair( L,  R )
                );
        }
 
        return  istr;
    }
    //-------------------------------------------------------------------------
    friend
    std::ostream    &   operator<<
        (
            std::ostream            &   ostr,
            T_points        const   &   points
        )
    {
        for( int  L = 0; L <=  points.point_of_line_ind_.rbegin()->first; ++L )
        {
            if  (
                    !points.point_of_line_ind_.count( L )
                )
            {
                ostr    <<  SPACE_SYMB;
            }
            else
            {
                int     symb_ind{};
 
                for (
                        auto
                        it  =   points.point_of_line_ind_.lower_bound( L );
                        it  !=  points.point_of_line_ind_.upper_bound( L );
                        ++it
                    )
                {
                    while   (
                                    symb_ind
                                <   it->second
                            )
                    {
                        ostr    <<  SPACE_SYMB;
                        ++symb_ind;
                    }
 
                    ostr    <<  ASTERISK_SYMB;
                    ++symb_ind;
                }//for
            }//else
 
            ostr    <<  std::endl;
        }//for
 
        return  ostr;
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    const   T_str   IFILE_NAME  =   "i.txt";
    const   T_str   OFILE_NAME  =   "o.txt";
 
    T_points        points;
 
    std::ifstream   ifile( IFILE_NAME );
 
    if( !ifile )
    {
        std::cout   <<  "Error!"
                    <<  std::endl;
 
        system("pause");
        exit(0);
    }//if
 
    ifile   >>  points;
    std::ofstream   ofile( OFILE_NAME );
    ofile   <<  points;
}