Formateo, E/S de archivos y espacios de nombres en C++

Introducción

En este laboratorio, aprenderá el formato, la entrada/salida de archivos y los espacios de nombres en C++. Aprenderá cómo formatear la salida, cómo formatear la entrada, cómo leer y escribir archivos y cómo usar espacios de nombres.

Skills Graph

Vista previa del contenido

Utilice manipuladores de E/S <iomanip> para formatear la entrada y la salida.

El encabezado <fstream> proporciona ifstream (flujo de archivo de entrada) y ofstream (flujo de archivo de salida) para la entrada y salida de archivos.

• Formateo de entrada y salida
• Entrada y salida de archivos
• Espacio de nombres

Formateo de Entrada/Salida utilizando Manipuladores de E/S (Encabezado )

El encabezado <iomanip> proporciona los llamados manipuladores de E/S para formatear la entrada y la salida:

• setw(int field-widht): establece el ancho del campo para la próxima operación de E/S. setw() no es pegajoso y debe ser emitido antes de cada operación de E/S. El ancho del campo se restablece al predeterminado después de cada operación (con el ancho suficiente para acomodar el campo).
• setfill(char fill-char): establece el carácter de relleno para el relleno hasta el ancho del campo.
• left|right|internal: establece la alineación
• fixed/scientific (para números de punto flotante): utiliza notación de punto fijo (por ejemplo, 12.34) o notación científica (por ejemplo, 1.23e+006).
• setprecision(int numDecimalDigits) (para números de punto flotante): especifica el número de dígitos después del punto decimal.
• boolalpha/noboolalpha (para bool): muestra los valores bool como cadena alfabética (true/false) o 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;
}

Salida:

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;
}

Salida:

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

Entrada/Salida de Archivos

Para probar la entrada y salida de archivos, primero cree un archivo llamado in.txt y escriba algunos números enteros en él separados por espacios. Después de la ejecución, el resultado del cálculo se escribirá en un archivo 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;
}

Salida:

12 15 35 26 68 Count = 5 average = 31.2

Notas del programa:

• Una vez que se abre el archivo, se pueden usar >> y << para la entrada y salida, de manera similar a cin >> y cout <<. (Nota avanzada: ifstream es una subclase de istream, a la que pertenece cin. ofstream es una subclase de ostream, a la que pertenece cout.)
• Del mismo modo, los manipuladores de E/S, como fixed, setprecision() y setw(), funcionan en los flujos de archivos.

Espacio de nombres

Cuando se utilizan diferentes módulos de biblioteca, siempre existe el riesgo de colisiones de nombres, ya que diferentes bibliotecas pueden utilizar el mismo nombre con fines diferentes. Este problema se puede resolver mediante el uso de espacios de nombres en C++. Un espacio de nombres es una colección de identificadores en el mismo ámbito de nombres. (En UML y Java se conoce como paquete.) El nombre de la entidad en un espacio de nombres está calificado por el nombre del espacio de nombres, seguido de :: (llamado operador de resolución de ámbito), en la forma namespace::entityName.

Para colocar una entidad en un espacio de nombres, use la palabra clave namespace de la siguiente manera:

// 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

Un espacio de nombres puede contener variables, funciones, matrices y tipos compuestos como clases y estructuras.

#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
}

Salida:

8
9

Usando Espacio de Nombres

// 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;

Resumen

Los pasos para la entrada/salida de archivos son:

1. Crear un ifstream para la entrada, o un ofstream para la salida.
2. Conectar el flujo a un archivo de entrada o salida a través de open(filename).
3. Realizar la salida formateada a través del operador de inserción de flujo <<, o la entrada a través del operador de extracción de flujo >>, de manera similar a cout << y cin >>.
4. Cerrar el archivo y liberar el flujo.

En C++, una entidad (variable, función o clase) pertenece al espacio de nombres global (identificado por :: sin nombre de espacio de nombres).