Manipuladores de Formatos

Todas as especificações de manipuladores predefinidos na linguagemforam incluídas no ficheiro iomanip.h. Se for necessário usar os

manipuladores o ficheiro iomanip.h deve ser incluído no programa.

Existem os manipuladores simples (sem argumentos) e osmanipuladores com argumentos.

Os manipuladoressimplessão os seguintes:

oct - o valor octal;dec - o valor decimal;hex - o valor hexadecimal;endl - ‘\n’ e apagar o buffer;ends - ‘\0’ e apagar o buffer

só para saída ;flush - apagar o buffer

só para saída ;ws - eliminação de espaços entre símbolos

Os manipuladores com argumentos são seguintes:

setfill(int caracter);setprecision(int pr);setw(int w);resetiosflags(long n);setiosflags(long n);etc.

cout << setw(5) << setfill('-') << hex << 10 << endl;cout << setiosflags(ios::uppercase|ios::internal|ios::showbase)

<< setfill('-') << hex << setw(5) << 10 << endl;cout << 10 << endl;cout << resetiosflags(ios::showbase) << 10 << endl;cout << setiosflags(ios::fixed) << setprecision(1)

<< 12.12345 << endl;

----a0X--A0XAA12.1

A área de acção para cada manipulador começa com o aparecimentodo manipulador e acaba depois de cancelado por outro manipulador

class my_f {};ostream& operator<<(ostream& s,my_f){ s.width(5); s.fill('-');

s.flags(ios::showpos);return s; }

my_f MF;cout << MF << 47 << endl;

cout << hex << a << b << c << dec << d;

Vamos considerar como podemos definir manipuladores novos.

--+47

Podemos também definir os manipuladores novos com argumentos.Vamos considerar, por exemplo, o manipulador wp(n,m) que

especifica a largura do campo n e precisão m para os valores comvírgula flutuante.

class my_manip {int n,m;ostream& (*f)(ostream&,int,int);

public:my_manip(ostream& (*F)(ostream&,int,int),int N, int M) : f(F), n(N), m(M) {}friend ostream& operator<<(ostream& s,my_manip& my){ return my.f(s,my.n,my.m); }

};

ostream& wi_pre(ostream& s, int n, int m){ s.width(n);

s.flags(ios::fixed);s.precision(m);return s;

}

my_manip wp(int n, int m){ return my_manip(wi_pre,n,m); }

int main(int argc, char* argv[]){ cout << 12.8765 << endl << wp(10,2) << 12.8765 << endl;

return 0;}

12.8765 12.88

Strings e Ficheiros - Classes (1)

• Existem classes específicas para trabalhar com strings e ficheiros em C++

• As operações I/O efectuam-se através de streams

Ficheiros e Strings

Strings e Ficheiros - Classes (2)

• Existem 3 tipos de streams– streams de leitura– streams de escrita– streams de leitura/escrita

Strings e Ficheiros - Classes (3)

• Classes de leitura para ficheiros e strings:– ifstream– istrstream

• Classes de escrita para ficheiros e strings:– ofstream– ostrstream

Strings e Ficheiros - Classes (4)

• Classes de leitura/escrita para ficheiros e strings:– fstream– strstream

Strings e Ficheiros - Classes (5)

• Todas estas classes são derivadas da classe ios

STRINGS

Strings - Construção (1)

• Classe istrstream– o objecto istrstream pode ser construído da

seguinte forma:

– istrstream in_str(char* psz);

– o objecto in_str irá ficar associado a uma string apontada por psz

Strings - Construção (2)

• Classe istrstream– o objecto istrstream também pode ser

construído da seguinte forma:

– istrstream in_str(char* pch, int nLength);

– o objecto in_str irá ficar associado a um array de caracteres normal com nLength caracteres

Strings - Construção (3)

• Classe ostrstream– o objecto ostrstream pode ser construído da

seguinte forma:

– ostrstream out_str;

– é criado um objecto out_str para escrita com reserva dinâmica de memória para novos caracteres

Strings - Construção (4)

• Classe ostrstream– o objecto ostrstream também pode ser

construído da seguinte forma:

– ostrstream out_str(char* pos, int Len, int OpenMode);

– OpenMode pode especificar ios::app ou ios::ate– pos aponta para uma string

Strings - Construção (5)

• Classe strstream = istrstream + ostrstream– o objecto strstream pode ser construído da

seguinte forma:

– strstream io_str;

– objecto io_str criado com buffer interno e dinâmico, inicialmente vazio

Strings - Construção (6)

• Classe strstream = istrstream + ostrstream– o objecto strstream também pode ser construído

da seguinte forma:

– strstream io_str(char* pos, int Len, int OpenMode);

– pos aponta para uma string já existente com Len caracteres

Strings - Construção (7)

• Sempre que possível deve deixar-se o objecto efectuar a reserva dinâmica do buffer interno.

Strings - Construção (7)

char* a_str = "Ola"; // 3 caracteresostrstream str(a_str, 10);

str << "nova string";

– Irá ocorrer um erro pois a_str só tem reservados 3 caracteres

Strings - Construção (8)

• A construção aconselhada seria:

ostrstream str;

str << "Ola";

str << "nova string";

OK - memória reservada dinamicamente

FICHEIROS

1. #include <fstream.h>

2. fstream source;

3. source.open(”my.txt", ios::in | ios::nocreate); if(!source.good()) {

cerr << "Nao foi possivel abrir o ficheiro fonte" << endl;exit(1); // pode usar controlo de excepções}

4. template <class Type> fstream& operator>>(fstream& source, set<Type> &S){................................

return source;}

5. source.close();

o nome lógico

o nome do ficheiro

Ficheiros - Construção (1)

• Classe ifstream– o objecto ifstream pode ser construído da

seguinte forma:

– ifstream in_file;

– o objecto in_file é criado mas nenhum ficheiro é aberto

Ficheiros - Construção (2)

• Classe ifstream– o objecto ifstream também pode ser construído

da seguinte forma:

– ifstream in_file("file.dat");

– o objecto in_file é criado e o ficheiro file.dat é aberto em modo de texto para leitura

Ficheiros - Construção (3)

• Qualquer construtor para objectos do tipo ficheiro, constrói apenas o objecto ficheiro sem abrir o ficheiro “físico” se não for dado o nome do ficheiro aquando da construção

Ficheiros - Construção (4)

• Classe ofstream– o objecto ofstream pode ser construído da

seguinte forma:

– ofstream out_file("file.dat", ios::binary);

– o objecto out_file quando criado, é associado ao ficheiro file.dat. Este é aberto em modo binário para escrita

Ficheiros - Construção (5)

• O objecto na construção aceita os seguintes parâmetros:

Flag Significadoios::app os dados são escritos no fim do ficheiroios::ate o apontador vai para o fim do ficheiro quando este é abertoios::in o ficheiro é aberto para leituraios::out o ficheiro é aberto para escritaios:.binary o ficheiro é aberto em modo binário. Se ausente o ficheiro é aberto em

modo texto.ios::trunc apaga o conteúdo de um ficheiro quando este é aberto para escritaios::nocreate falha a abertura do ficheiro se este não existir (apenas para ficheiro de

escrita)ios::noreplace não substitui um ficheiro existente. Se este existir, falha a

abertura

Ficheiros - Construção (6)

• Classe fstream = ifstream + ofstream– o objecto fstream pode ser criado da seguinte

forma:

– fstream io_file("file.dat", ios::in | ios::out | ios::binary);

– é criado o objecto io_file para leitura/escrita em modo binário, associado ao ficheiro file.dat

Ficheiros - Verificação (1)

• A verificação da abertura efectiva de um ficheiro deve ser sempre realizada antes de efectuar qualquer operação I/O sobre este

Ficheiros - Verificação (2)

• Exemplos para verificação da abertura de um ficheiro

if(in_file.bad()) {

cerr << "o ficheiro nao foi aberto" << endl;

exit(1);

}

if(!in_file) {

cerr << "o ficheiro nao foi aberto" << endl;

exit(1);

}

if(in_file.is_open() == 0) {

cerr << "o ficheiro nao foi aberto" << endl;

exit(1);

}

Ficheiros - Verificação (3)

• O método eof() permite saber se foi atingido o fim do ficheiro

while(!io_file.eof()) {

// lê ficheiro

// …

}

LEITURA / ESCRITA

Streams - Leitura/Escrita (1)

• A leitura de strings e ficheiros é efectuada de forma semelhante

• As suas classes derivam de uma classe I/O comum - classe ios

Streams - Leitura/Escrita (2)

char str[10];istrstream in_str("Ola");ifstream in_file("file.dat");

in_str >> str;in_file >> str;in_str.read(str, 3);in_file.read(str, 3);in_str.getline(str,3);in_file.getline(str, 3);

• Leituras de uma string e de um ficheiro para str efectuadas de forma idêntica

Streams - Leitura/Escrita (3)

char str1[] = "PP1";

strstream out_str;

fstream out_file("file2.dat", ios::out);

out_str << str1;

out_file << str1;

out_str.write(str1, 6);

out_file.write(str1, 6);

• Escrita efectuada, numa string e num ficheiro, de forma idêntica

int main(int argc, char* argv[]){ char str[10];

istrstream in_str("Ola");ifstream in_file("file.dat"); // Aveiroin_file.getline(str, 5);cout << str << endl; // O resultado: Aveiin_str >> str;cout << str << endl; // O resultado: Olain_file >> str; // O resultado: rocout << str << endl;char str1[10] = "PP1";strstream out_str;fstream out_file("file2.dat", ios::out);out_str << str1;out_file << str1;out_str.read(str, 1);cout << str << endl; // O resultado: Po. . . . . . . . . . . . . . . . . . . . . .

Aveiro

PP1

Destrutores (1)

• Todos os objectos têm destrutores que libertam o espaço reservado para o objecto

Destrutores (2)

• No caso de ficheiros é boa política efectuar o fecho do objecto (ficheiro) assim que este já não seja necessário. Desta forma são libertados recursos do sistema mais cedo

int main(int argc, char* argv[]){ fstream source,destination;

source.open("source.txt", ios::in | ios::nocreate);if(!source.good()) { cerr << "Nao foi possivel abrir o ficheiro fonte" << endl; exit(1); }

destination.open("out1.txt", ios::out);if(!destination) { cerr << "Nao foi possivel abrir o ficheiro out1" << endl; exit(1);}

char str[50];source >> str;cout << str << endl;destination.write(str,7);source >> str;cout << str << endl;destination.write(str,7); source >> str;cout << str << endl;destination.write(str,7);source >> str;cout << str << endl;destination.write(str,7); source.close();destination.close();return 0;

}

Aveiro Lisboa PortoCoimbra FaroBraga

Aveiro Lisboa Porto Coimbra

int main(int argc, char* argv[]){ fstream source,destination;

StrString my_str;int no_of_caracteres = 0, no_of_words = 0;///////////////////////////////////////////////////////////////////// Abertura dos ficheiros///////////////////////////////////////////////////////////////////source.open("source.txt", ios::in | ios::nocreate);if(!source.good()) {

cerr << "Nao foi possivel abrir o ficheiro fonte" << endl;exit(1);

}

destination.open("out1.txt", ios::out);if(!destination) {

cerr << "Nao foi possivel abrir o ficheiro out1" << endl;exit(1);

}

source >> my_str; // leitura da linhano_of_caracteres = my_str.length(); // incrementa

// o nº de caracteresno_of_words = my_str.words(); // incrementa o nº de palavrascout << my_str << endl; // escreve a linhadestination << my_str << endl; // escreve a linha

// em destination

my_str = " ------------- Estatistica --------------:";

cout << my_str << endl;cout << "Numero de caracteres = " << no_of_caracteres << endl;cout << "Numero de palavras = " << no_of_words << endl;source.close();destination.close();return 0;

}