Wczytywanie danych z pliku tekstowego

#include <iostream>
#include <conio.h>   // getch()
#include <fstream>
#include <string>

using namespace std;

int wplacajacy;

struct sponsorzy
{
    string nazwisko;
    double kwota;
};

int main()
{
    fstream plik;
    plik.open( "dokument.txt" );
   
    cout << "Liczba wplacajacych: ";
   
    plik >> wplacajacy;
   
    cout << wplacajacy << endl;
   
   
    sponsorzy * wsk = new sponsorzy[ wplacajacy ];
   
    for( int i = 0; i < wplacajacy; i++ )
    {
        cout << i + 1 << ") Nazwisko: ";
        getline( plik, wsk[ i ].nazwisko );
       
        cout << "   Kwota: ";
        plik >> wsk[ i ].kwota;
    }
   
   
    cout << "\nNasi wspaniali sponsorzy\n";
   
    for( int i = 0; i < wplacajacy; i++ )
    {
        if( wsk[ i ].kwota >= 10000 )
             cout << wsk[ i ].nazwisko << endl;
       
        //specjalnie nie wyswietlam slowa brak
    }
   
    cout << "\nNasi sponsorzy\n";
   
    for( int i = 0; i < wplacajacy; i++ )
         cout << wsk[ i ].nazwisko << endl;
   
   
    getch();
    return 0;
}

#include <iostream>
#include <limits>
#include <fstream>
#include <string>

struct Patron {
    std::string fulname;
    double amt;
   
    template < class InputStream >
    friend InputStream & operator >>( InputStream & input, Patron & patron )
    {
        std::getline( input, patron.fulname );
        input >> patron.amt;
        input.ignore( std::numeric_limits < std::streamsize >::max(), '\n' );
        return input;
    }
   
    template < class OutputStream >
    friend OutputStream & operator <<( OutputStream & output, const Patron & patron )
    {
        output << patron.fulname.data() << '\n' << patron.amt;
        return output;
    }
};

template < class InputStream >
std::size_t readSizeArrFromFile( InputStream & input )
{
    std::size_t size;
    input >> size;
    input.ignore( std::numeric_limits < std::streamsize >::max(), '\n' );
    return size;
}

template < class OutputStream >
void writeSizeArrToFile( std::size_t size, OutputStream & output )
{
    output << size << '\n';
}

template < class T, class InputStream >
void readFromStreamToArray( T arr[], std::size_t size, InputStream & input )
{
    for( std::size_t i = 0; i < size; ++i ) {
        input >> arr[ i ];
    }
}

template < class T, class OutputStream >
void writeToStreamFromArray( T arr[], std::size_t size, OutputStream & output )
{
    for( std::size_t i = 0; i < size; ++i )
    {
        output << arr[ i ] << '\n';
    }
}


int main()
{
    std::ifstream fin( "test.txt" );
    std::size_t patronsSize { };
    Patron * patrons = nullptr;
    if( fin.is_open() ) {
        patronsSize = readSizeArrFromFile < std::ifstream >( fin );
        patrons = new Patron[ patronsSize ]; // zalecam użyć std::vector
        readFromStreamToArray < Patron, std::ifstream >( patrons, patronsSize, fin );
        writeToStreamFromArray < Patron, std::ostream >( patrons, patronsSize, std::cout );
    }
    else {
        std::cerr << "file not opened\n";
    }
   
    std::ofstream fout( "test2.txt" ); // tutaj kontrolny zapis do drugiego pliku
    if( fout.is_open() ) {
        writeSizeArrToFile < std::ofstream >( patronsSize, fout );
        writeToStreamFromArray < Patron, std::ofstream >( patrons, patronsSize, fout );
    }
   
    if( fin.is_open() ) {
        delete[] patrons;
    }
}