Manipuladores de Formatos

1. Manipuladores de Formatos Todas as especificações de manipuladores predefinidos na linguagem foram 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 os manipuladores com argumentos. 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 simples são os seguintes:

2. Os manipuladores com argumentos são seguintes: setfill(int caracter); setprecision(int pr); setw(int w); resetiosflags(long n); setiosflags(long n); etc. ----a 0X--A 0XA A 12.1 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;

3. A área de acção para cada manipulador começa com o aparecimento do manipulador e acaba depois de cancelado por outro manipulador cout << hex << a << b << c << dec << d; Vamos considerar como podemos definir manipuladores novos. 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; --+47

4. 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 com ví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); } };

5. 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

6. Ficheiros e Strings 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

7. Strings e Ficheiros - Classes (2) • Existem 3 tipos de streams • streams de leitura • streams de escrita • streams de leitura/escrita

8. Strings e Ficheiros - Classes (3) • Classes de leitura para ficheiros e strings: • ifstream • istrstream • Classes de escrita para ficheiros e strings: • ofstream • ostrstream

9. Strings e Ficheiros - Classes (4) • Classes de leitura/escrita para ficheiros e strings: • fstream • strstream

10. Strings e Ficheiros - Classes (5) • Todas estas classes são derivadas da classe ios

11. STRINGS

12. 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

13. 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

14. 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

15. 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

16. 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

17. 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

18. Strings - Construção (7) • Sempre que possível deve deixar-se o objecto efectuar a reserva dinâmica do buffer interno.

19. Strings - Construção (7) char* a_str = "Ola"; // 3 caracteres ostrstream str(a_str, 10); str << "nova string"; • Irá ocorrer um erro pois a_str só tem reservados 3 caracteres

20. Strings - Construção (8) • A construção aconselhada seria: ostrstream str; str << "Ola"; str << "nova string"; OK - memória reservada dinamicamente

21. FICHEIROS

22. o nome lógico o nome do ficheiro 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();

23. 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

24. 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

25. 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

26. 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

27. Ficheiros - Construção (5) • O objecto na construção aceita os seguintes parâmetros: Flag Significado ios::app os dados são escritos no fim do ficheiro ios::ate o apontador vai para o fim do ficheiro quando este é aberto ios::in o ficheiro é aberto para leitura ios::out o ficheiro é aberto para escrita ios:.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 escrita ios::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

28. 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

29. 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

30. 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); }

31. Ficheiros - Verificação (3) • O método eof() permite saber se foi atingido o fim do ficheiro while(!io_file.eof()) { // lê ficheiro // … }

32. LEITURA / ESCRITA

33. 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

34. 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

35. 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

36. Aveiro PP1 int main(int argc, char* argv[]) { char str[10]; istrstream in_str("Ola"); ifstream in_file("file.dat"); // Aveiro in_file.getline(str, 5); cout << str << endl; // O resultado: Avei in_str >> str; cout << str << endl; // O resultado: Ola in_file >> str; // O resultado: ro cout << 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 . . . . . . . . . . . . . . . . . . . . . . Exemplo

37. Destrutores (1) • Todos os objectos têm destrutores que libertam o espaço reservado para o objecto

38. 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

39. 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); }

40. Aveiro Lisboa Porto Coimbra 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 Porto Coimbra Faro Braga

41. 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); }

42. source >> my_str; // leitura da linha no_of_caracteres = my_str.length(); // incrementa // o nº de caracteres no_of_words = my_str.words(); // incrementa o nº de palavras cout << my_str << endl; // escreve a linha destination << 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; }