manipuladores de formatos todas as especificações de manipuladores predefinidos na linguagem foram...
TRANSCRIPT
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;
}