Acesta este un cod demonstrativ pentru parsarea fişierului de ieşire folosind metoda obiectuală:
== code(cpp) |

class OutputPrinter
{

#include <cstdio>
#include <cstring>
 
using namespace std;
 
class OutParser {
private:
    FILE *fout;
    char *buff;
    int sp;
 
    void write_ch(char ch) {
        if (sp == 50000) {
            fwrite(buff, 1, 50000, fout);
            sp = 0;
            buff[sp++] = ch;
        } else {
            buff[sp++] = ch;
        }
    }
 
 

public:

    OutputPrinter () {}
    OutputPrinter (char *file_name) {output_file = fopen (file_name, "w"); memset (sir, 0, sizeof (sir));}
    OutputPrinter &operator << (int val)
    {
        int cif[15];
        cif[0] = 0;
        if (val == 0) cif[0] = 1, cif[1] = 0;
        while (val) cif[++cif[0]] = val % 10, val /= 10;
        for (int i=cif[0]; i>=1; i--)
            sir[pos ++] = cif[i] + '0';
        if (pos >= max_l) CheckFinish ();

    OutParser(const char* name) {
        fout = fopen(name, "w");
        buff = new char[50000]();
        sp = 0;
    }
    ~OutParser() {
        fwrite(buff, 1, sp, fout);
        fclose(fout);
    }
 
    OutParser& operator << (int vu32) {
        if (vu32 <= 9) {
            write_ch(vu32 + '0');
        } else {
            (*this) << (vu32 / 10);
            write_ch(vu32 % 10 + '0');
        }

        return *this;
    }

    OutputPrinter &operator << (char c)
    {
        sir[pos ++] = c;
        if (pos >= max_l) CheckFinish ();

 
    OutParser& operator << (long long vu64) {
        if (vu64 <= 9) {
            write_ch(vu64 + '0');
        } else {
            (*this) << (vu64 / 10);
            write_ch(vu64 % 10 + '0');
        }
        return *this;
    }
 
    OutParser& operator << (char ch) {
        write_ch(ch);

        return *this;
    }

    OutputPrinter &operator << (char *str)
    {
        while (*str)
        {
            sir[pos ++] = *str, str ++;
            if (pos >= max_l) CheckFinish ();

    OutParser& operator << (const char *ch) {
        while (*ch) {
            write_ch(*ch);
            ++ch;

        }
        return *this;
    }

    ~OutputPrinter () {fprintf (output_file, "%s", sir);}
private:
    FILE *output_file;
    static const int max_l = 50000;
    int pos = 0;
    char sir[max_l + 20];
    void CheckFinish () {fprintf (output_file, "%s", sir), pos = 0, memset (sir, 0, sizeof (sir));}

};

==
 
h3. Cum folosim acest cod?
 
Aveţi mai jos un exemplu care urmează sintaxa $fstream$:
 
== code(cpp) |
int main()
{
	OutParser fout("exemplu.out");
	fout << 324 << "sdfjhj 87473hriufhe" << '\n' << 638274623846 << '\n'; // !!! endl nu funcţionează, şi oricum şi în fstream este lent. Folosiţi '\n'.
	return 0;
}
==
 
h2. Cod compatibil cu limbajul C (procedural)
 
Această variantă este perfect compatibilă cu standardele C, întrucât foloseşte funcţii pentru fiecare tip în parte.
 
== code(cpp) |
#include <stdio.h>
 
/** Funcţiile necesare parsării fişierului de ieşire **/
FILE *_fout;
int _out_loc; char _out_buff[50000];
 
void write_init(const char* name) // Apelaţi această funcţie la începutul funcţiei <main>
{
    _fout = fopen(name, "w");
    _out_loc = 0;
}
 
void write_ch(char ch) // Apelaţi această funcţie pentru a scrie un caracter (cum ar fi ' ' sau '\n')
{
    if (_out_loc == 50000) {
        fwrite(_out_buff, 1, 50000, _fout);
        _out_loc = 0;
        _out_buff[_out_loc++] = ch;
    } else {
        _out_buff[_out_loc++] = ch;
    }
}
 
void write_u32(unsigned int vu32) // Apelaţi această funcţie pentru a scrie un număr ce se încadrează în categoria <unsigned int>
{
    if (vu32 <= 9) {
        write_ch(vu32 + '0');
    } else {
        write_u32(vu32 / 10);
        write_ch(vu32 % 10 + '0');
    }
}
 
void write_u64(unsigned long long vu64) // Apelaţi această funcţie pentru a scrie un număr ce se încadrează în categoria <unsigned long long>
{
    if (vu64 <= 9) {
        write_ch(vu64 + '0');
    } else {
        write_u64(vu64 / 10);
        write_ch(vu64 % 10 + '0');
    }
}
 
void write_appendix() // ###! ATENŢIE, Apelaţi această funcţie la finalul prgramului. Altfel, fisierul outpt NU VA CONŢINE ÎN ÎNTREGIME ceea ce doriţi!
{
    fwrite(_out_buff, 1, _out_loc, _fout);
    fclose(_fout);
}
==
 
h3. Cum folosim acest cod?
 
Aveţi mai jos un exemplu care urmează sintaxa $C$:
 
== code(cpp) |
int main()
{
	write_init("exemplu.out");
	write_u32(1465423745);
	write_ch(' ');
	write_u64(23441465423745);
	write_ch('\n');
	write_ch('&');
	write_appendix(); // Din nou, NU UITAŢI ACEASTĂ FUNCŢIE! Ea copiază ce a rămas din buffer în fişier.
	return 0;
}

==