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

#include <cstdio>
#include <cstring>
 
using namespace std;

#include <stdio.h>

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;
        }
    }
 
 

	FILE *fout;
	char *buff;
	int sp;
 
	void write_ch(char ch) {
		if (sp == 4096) {
			fwrite(buff, 1, 4906, fout);
			sp = 0;
			buff[sp] = ch;
		} else {
			buff[sp++] = ch;
		}
	}
 
 

public:

    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;
    }
 
    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;
    }
    OutParser& operator << (const char *ch) {
        while (*ch) {
            write_ch(*ch);
            ++ch;
        }
        return *this;
    }

	OutParser(const char* name) {
		fout = fopen(name, "w");
		buff = new char[4096]();
		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;
	}
 
	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;
	}
	OutParser& operator << (const char *ch) {
		while (*ch) {
			write_ch(*ch);
			++ch;
		}
		return *this;
	}

};
==

== code(cpp) |
#include <stdio.h>

 
/** Funcţiile necesare parsării fişierului de ieşire **/

 
/** Funcţiile necesare parsării fişierului de intrare **/

FILE *_fout;

int _out_loc; char _out_buff[50000];
 

int _out_loc; char _out_buff[4096];
 

void write_init(const char* name) // Apelaţi această funcţie la începutul funcţiei <main>
{

    _fout = fopen(name, "w");
    _out_loc = 0;

	_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;
    }

	if (_out_loc == 4096) {
		fwrite(_out_buff, 1, 4096, _fout);
		_out_loc = 0;
	} 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');
    }

	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);

	if (vu64 <= 9) {
		write_ch(vu64 + '0');
	} else {
		write_u64(vu64 / 10);
		write_ch(vu64 % 10 + '0');
	}

}

==
 
h3. Cum folosim acest cod?
Aveţi mai jos un exemplu care urmează sintaxa $C$:
 
== code(cpp) |
int main()

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!

{

	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;

	fwrite(_out_buff, 1, _out_loc, _fout);
	fclose(_fout);

}
==