Dominando Formatação C++, E/S de Arquivos e Namespaces

Introdução

Neste laboratório, você aprenderá sobre formatação, entrada/saída de arquivos (file I/O) e namespaces em C++. Você aprenderá como formatar a saída, como formatar a entrada, como ler e escrever arquivos e como usar namespaces.

Pré-visualização do Conteúdo

Use manipuladores de I/O <iomanip> para formatar a entrada e a saída.

O cabeçalho <fstream> fornece ifstream (fluxo de arquivo de entrada) e ofstream (fluxo de arquivo de saída) para entrada e saída de arquivos.

Formatação de entrada e saída
Entrada e saída de arquivos
Namespace

O cabeçalho <iomanip> fornece os chamados manipuladores de I/O para formatação de entrada e saída:

setw(int field-widht): define a largura do campo para a próxima operação de I/O. setw() não é "sticky" (pegajoso) e deve ser emitido antes de cada operação de I/O. A largura do campo é redefinida para o padrão após cada operação (com largura suficiente para acomodar o campo).
setfill(char fill-char): define o caractere de preenchimento para o preenchimento da largura do campo.
left|right|internal: define o alinhamento
fixed/scientific (para números de ponto flutuante): usa notação de ponto fixo (por exemplo, 12.34) ou notação científica (por exemplo, 1.23e+006).
setprecision(int numDecimalDigits) (para números de ponto flutuante): especifica o número de dígitos após a vírgula decimal.
boolalpha/noboolalpha (para bool): exibe valores bool como string alfabética (true/false) ou 1/0.

/* Test Formatting Output */
#include <iostream>
#include <iomanip>    // Needed to do formatted I/O
using namespace std;

int main() {
   // Floating point numbers
   double pi = 3.14159265;
   cout << fixed << setprecision(4); // fixed format with 4 decimal places
   cout << pi << endl;
   cout << "|" << setw(8) << pi << "|" << setw(10) << pi << "|" << endl;
      // setw() is not sticky, only apply to the next operation.
   cout << setfill('-');
   cout << "|" << setw(8) << pi << "|" << setw(10) << pi << "|" << endl;
   cout << scientific;  // in scientific format with exponent
   cout << pi << endl;

   // booleans
   bool done = false;
   cout << done << endl;  // print 0 (for false) or 1 (for true)
   cout << boolalpha;     // print true or false
   cout << done << endl;
   return 0;
}

Saída:

3.1416
|  3.1416|    3.1416|
|--3.1416|----3.1416|
3.1416e+00
0
false

/* Test Formatting Input */
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;

int main() {
   string areaCode, phoneCode;
   string inStr;

   cout << "Enter your phone number in this format (xxx)xxx-xxxx : ";
   cin.ignore();   // skip '('
   cin >> setw(3) >> areaCode;
   cin.ignore();   // skip ')'
   cin >> setw(3) >> phoneCode;
   cin.ignore();   // skip '-'
   cin >> setw(4) >> inStr;
   phoneCode += inStr;

   cout << "Phone number is (" << areaCode << ")"
        << phoneCode.substr(0, 3) << "-"
        << phoneCode.substr(3, 4) << endl;
   return 0;
}

Saída:

Enter your phone number in this format (xxx)xxx-xxxx :  254 845 9946
Phone number is (254)845-9946

Entrada/Saída de Arquivos

Para testar a entrada e saída de arquivos, primeiro crie um arquivo chamado in.txt e escreva alguns números inteiros nele, separados por espaço. Após a execução, o resultado do cálculo será escrito em um arquivo out.txt.

/* Test File I/O
   Read all the integers from an input file and
   write the average to an output file        */
#include <iostream>
#include <fstream>   // file stream
#include <cstdlib>
using namespace std;

int main() {
   ifstream fin;   // Input stream
   ofstream fout;  // Output stream

   // Try opening the input file
   fin.open("in.txt");
   if (!fin.is_open()) {
      cerr << "error: open input file failed" << endl;
      abort();  // Abnormally terminate the program (in <cstdlib>)
   }

   int sum = 0, number, count = 0;
   while (fin >> number) {
      // Use >> to read
      cout << number << " ";
      sum += number;
      ++count;
   }
   double average = double(sum) / count;
   cout << "Count = " << count << " average = " << average << endl;
   fin.close();

   // Try opening the output file
   fout.open("out.txt");
   if (!fout.is_open()) {
      cerr << "error: open output file failed" << endl;
      abort();
   }
   // Write the average to the output file using <<
   fout << average;
   fout.close();
   return 0;
}

Saída:

12 15 35 26 68 Count = 5 average = 31.2

Notas do Programa:

Uma vez que o arquivo é aberto, você pode usar >> e << para entrada e saída, de forma semelhante a cin >> e cout <<. (Nota avançada: ifstream é uma subclasse de istream, onde cin pertence. ofstream é uma subclasse de ostream, onde cout pertence.)
Da mesma forma, manipuladores de I/O, como fixed, setprecision() e setw(), funcionam nos fluxos de arquivo.

Namespace (Espaço de Nomes)

Ao usar diferentes módulos de biblioteca, sempre há potencial para conflitos de nomes, pois diferentes bibliotecas podem usar o mesmo nome para propósitos diferentes. Esse problema pode ser resolvido por meio do uso de namespace (espaço de nomes) em C++. Um namespace é uma coleção de identificadores sob o mesmo escopo de nomenclatura. (É conhecido como package (pacote) em UML e Java.) O nome da entidade sob um namespace é qualificado pelo nome do namespace, seguido por :: (conhecido como operador de resolução de escopo), na forma de namespace::entityName.

Para colocar uma entidade sob um namespace, use a palavra-chave namespace da seguinte forma:

// create a namespace called myNamespace for the enclosed entities
namespace myNameSpace {
   int foo;               // variable
   int f() { ...... };    // function
   class Bar { ...... };  // compound type such as class and struct
}

// To reference the entities, use
myNameSpace::foo
myNameSpace::f()
myNameSpace::Bar

Um namespace pode conter variáveis, funções, arrays e tipos compostos, como classes e estruturas.

#include <iostream>

namespace a {   // contains variables
   int i1 = 8;
   int i2 = 9;
}

namespace b {   // contains function
   int max(int n1, int n2) {
      return (n1 > n2) ? n1 : n2;
   }
}

int main() {
   std::cout << a::i1 << std::endl;                // 8
   std::cout << b::max(a::i1, a::i2) << std::endl; // 9
}

Saída:

8
9

Usando Namespace

// Use the fully qualified names,
// such as std::cout, std::endl, std::setw() and std::string.
std::cout << std::setw(6) << 1234 << std::endl;

// Use a using declaration to declare the particular identifiers.
using std::cout;
using std::endl;
......
cout << std::setw(6) << 1234 << endl;

// Use a using namespace directive.
using namespace std:
......
cout << setw(6) << 1234 << endl;

// For long namespace name, you could define a shorthand (or alias) to the namespace
namespace shorthand = namespace-name;

Resumo

As etapas para entrada/saída de arquivos são:

Crie um ifstream para entrada ou ofstream para saída.
Conecte o fluxo a um arquivo de entrada ou saída via open(filename).
Execute a saída formatada via operador de inserção de fluxo <<, ou entrada via operador de extração de fluxo >>, semelhante a cout << e cin >>.
Feche o arquivo e libere o fluxo.

Em C++, uma entidade (variável, função ou classe) pertence ao global namespace (espaço de nomes global) (identificado por :: sem nome de namespace).

Formatação C++, E/S de Arquivos e Namespace

Introdução

Pré-visualização do Conteúdo

Formatação de Entrada/Saída usando Manipuladores IO (Header )

Entrada/Saída de Arquivos

Namespace (Espaço de Nomes)

Resumo