Rafa: anadiendo file i/o

README-es.md

@@ -4,7 +4,7 @@
 ![main2.png](images/main2.png)
 ![main3.png](images/main3.png)
 
-[Verano 2016-Ive]
+[Verano 2016-Ive - Rafa]
 
 Los arreglos de datos (*arrays*) nos facilitan guardar y trabajar con grupos de datos del mismo tipo. Los datos se guardan en espacios de memoria consecutivos a los que se puede acceder utilizando el nombre del arreglo e índices o suscritos que indican la posición en que se encuentra el dato. Las estructuras de repetición nos proveen una manera simple de acceder a los datos de un arreglo. En la experiencia de laboratorio de hoy practicarás el uso de contadores y arreglos de una dimensión para implementar un programa en el que usarás la Ley de Benford para detectar   archivos con datos falsificados.
 
@@ -123,6 +123,147 @@ La **frecuencia de ocurrencia** se define como la razón del número de veces qu
 
 **Figura 5.** Histograma para la frecuencia de los dígitos líderes en los datos de muestra.
 
+
+---
+
+---
+
+
+## Leyendo datos de un archivo de texto en C++
+
+En este laboratorio crearás un programa que lee datos de un archivo de texto.  Puedes saltar esta sección si te sientes cómodo con tus destrezas de manejo de archivos de texto en C++. 
+
+C++ provee funciones para leer y escribir datos en archivos. En este laboratorio usarás uno de los métodos más básicos de lectura: lectura secuencial de archivos de texto. Los **archivos de texto** consisten de caracteres ASCII que representan datos en alguno de los tipos primitivos de C++. Por ejemplo, supón que el archivo `nameAge.txt` contiene algunos datos sobre nombres y edades.
+
+```
+Tomas 34
+Marta 55
+Remigio 88
+Andrea 43
+```
+
+Para **leer** un archivo de texto como parte de un programa en C++, debemos conocer cómo están organizados los datos en el archivo y qué tipo de datos deseamos leer. El archivo `nameAge.txt` contiene cuatro líneas y cada línea contiene un string y un entero. A continuación un programa para leer el archivo de principio a fin mientras se imprimen los datos que se van leyendo en cada línea. Lee los comentarios del programa para entiendas sus partes:
+
+
+```
+
+#include <iostream>
+
+// fstream es el header file que contiene clases, funciones y objetos 
+// para trabjar con lectura y escritura de archivos.
+#include <fstream>  
+
+using namespace std;
+
+int main(){
+
+    // Usaremos las siguientes dos variables para asignarle los
+    // valores que leemos en cada linea del archivo.
+    string name;
+    int age;
+    
+    // Definimos el objeto que representará al archivo 
+    ifstream inFile;
+    
+    // Invocamos a la funcion open para que abra el file `nameAge.txt` 
+    inFile.open("nameAge.txt");
+    
+    
+    // Verificamos que el archivo ha sido debidamente abierto
+    if (!inFile.is_open()) {
+        cout << "Error openning file nameAge.txt\n";
+        exit(1);
+    }
+
+    
+    // Mientras haya datos por leer en el archivo, leer un string
+    // y un entero. Observa como usamos simbolo `>>`, parecido
+    // a como lo usamos con cin.
+    
+    while (inFile  >> name >> age) {
+        cout << name << " : " << age << endl;
+    }
+    
+    // Cerrar el archivo. 
+    inFile.close();
+    
+    return 0;
+}
+```
+
+El objeto `ifstream` permite que leamos el archivo de forma **secuencial**. Lleva cuenta de la próxima posición a leer dentro del archivo. Cada vez que leemos uno o más datos (usando `inFile >> ____`) el objeto adelanta su posición para que el próximo `inFile >> ___` pueda leer los datos siguientes.
+
+Observa la linea `inFile  >> name >> age`. Esa instrucción realiza varias tareas:
+
+* Lee un string y un int del archivo (si queda algo por leer) y se los asigna a las variables `name` y `age`.
+* Si pudo leer ambos datos, la expresión `inFile  >> name >> age` evalúa `true`.
+* De lo contrario, la expresión evalúa `false`, saliendo del bloque while.
+
+A continuación algunos pedazos de código C++ para tareas comunes de lectura de archivos. Observa que en todas ellas:
+
+1. Creamos un objecto de clase `ifstream`, llamamos a su función `open` y verificamos que el archivo abrió correctamente.
+2. Creamos una o más variables para asignarles los valores que leeremos del archivo.
+3. Implementamos un ciclo que se repite mientras hayan datos que leer del archivo.
+4. Cerramos el archivo.
+
+
+
+**Ejemplo 1**: Leer un archivo que solo contiene datos enteros y acumular sus valores.
+
+```
+    ifstream inFile;
+    int n;
+    int accum = 0;
+    
+    inFile.open("nums.txt");
+
+    if (!inFile.is_open()) {
+        cout << "Error openning file nums.txt\n";
+        exit(1);
+    }
+
+    while (inFile  >> n) {
+        accum = accum + n;
+    }
+
+    cout << "Total: "  << accum << endl;
+    
+    inFile.close();
+```
+
+**Ejemplo 2**: Contar el número de líneas en un archivo que contiene  un nombre por línea. Luego imprimir el contenido de la línea del medio.
+
+```
+    ifstream inFile;
+    string name;
+    int ctr = 0;
+    
+    inFile.open("names.txt");
+
+    if (!inFile.is_open()) {
+        cout << "Error openning file names.txt\n";
+        exit(1);
+    }
+
+    while (inFile  >> name) {
+        ctr++;
+    }
+
+    cout << "Total number of lines: " << ctr << endl;
+
+	// Estos dos comandos retroceden el file al principio.
+    inFile.clear();
+    inFile.seekg(0);
+
+    for (int i = 0; i <= ctr / 2; i++) {
+        inFile >> name;
+    }
+
+    cout << "The name at the position " << ctr / 2 << ": " << name << endl;
+
+    inFile.close();
+```
+
 ---
 
 ---