View
113
Download
0
Category
Preview:
Citation preview
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;
}
Recommended