Capitulo 3

Clases en C++.

Clases vs estructuras

Clase:

Una clase se puede considerar como un patrón para construir objetos. En C++, un objeto es sólo un tipo de variable de una clase determinada. Es importante distinguir entre objetos y clases, la clase es simplemente una declaración, no tiene asociado ningún objeto, de modo que no puede recibir mensajes ni procesarlos, esto únicamente lo hacen los objetos.

Interfaz:

Las clases y por lo tanto también los objetos, tienen partes públicas y partes privadas.

Algunas veces llamaremos a la parte pública de un objeto su interfaz. Se trata de la única parte del objeto que es visible para el resto de los objetos, de modo que es lo único de lo que se dispone para comunicarse con ellos.

Herencia:

Veremos que es posible diseñar nuevas clases basándose en clases ya existentes. En C++ esto se llama derivación de clases, y en POO herencia. Cuando se deriva una clase de otra, normalmente se añadirán nuevos métodos y datos. Es posible que algunos de estos métodos o datos de la clase original no sean válidos, en ese caso pueden ser enmascarados en la nueva clase o simplemente eliminados. El conjunto de datos y métodos que sobreviven, es lo que se conoce como herencia.

Definir una clase

La primera palabra que aparece es lógicamente class que sirve para declarar una clase. Su uso es parecido a la ya conocida struct:

La lista de clases base se usa para derivar clases, de momento no le prestes demasiada atención, ya que por ahora sólo declararemos clases base.

La lista de miembros será en general una lista de funciones y datos.

Los datos se declaran del mismo modo en que lo hacíamos hasta ahora, salvo que no pueden ser inicializados, recuerda que estamos hablando de declaraciones de clases y no de definiciones de objetos. Veremos el modo de inicializar las variables de un objeto.

Las funciones pueden ser simplemente declaraciones de prototipos, que se deben definir aparte de la clase o también definiciones.

Cuando se definen las variables / asignan, fuera de la clase se debe usar el operador de ámbito "::", esto se vio al final de los ejercicios de estruct.

Mostrare una clase sencilla, cuyas variables miembro se asignan desde las funciones miembro:

1.- Evidencia modificar el programa anterior para que muestre otra película (incluyendo las 2 anteriores), tu decide que película y que actores

2.- Crea un programa que incluya una clase de tipo public, tu encojes el tema puede ser reducido, usa el nombre de mi_programa.cpp

Para este caso las variables miembro y la funciones miembro son de tipo public, en este punto no es útil hacerlo así ya que no están encapsulados los datos, pero nos sirve para ver como funciona la clase, en el ejercicio que sigue trataremos los atributos, por el momento revisa el programa pelicula.cpp, y analiza lo que se desarrollo .

Para CodeBlocks

Para NetBeans

Para CLI

Lo veremos otro ejemplo, usando private.

Para CodeBlocks

Para NetBeans

Para CLI

Evidencia agrega mas variables miembro, y de forma que puedan estar relacionadas con lo que estamos usando como:  telefono, curp, etc. envia la evidencia con el nombre de clases_private.cpp

Nuestra clase "Persona" tiene los miembros de tipo de datos: a,b,edad, de tipo int, y nombre,apellido1,apellido2,direccion de tipo string, hay que observar como se establecen como miembros de la clase, std::string nombre, puede omitirse si se añade using namespace std; pero lo usaremos para ubicar estas funciones miembro

Y dos funciones, una para leer esos valores y otra para modificarlos.

En el caso de la función "leeDatos" la hemos declarado en el interior de la clase y definido fuera, observa que en el exterior de la declaración de la clase tenemos que usar la expresión:

Para que quede claro que nos referimos a la función "leeDatos" de la clase "Persona". Ten en cuenta que pueden existir otras clases que tengan funciones con el mismo nombre, y también que si no especificamos que estamos definiendo una función de la clase "Persona", en realidad estaremos definiendo una función tradicional.

En el caso de la función "guardaDatos" la hemos definido en el interior de la propia clase.

Esto lo haremos sólo cuando la definición sea muy simple, ya que dificulta la lectura y comprensión del programa.

Además, las funciones definidas de este modo serán tratadas como "inline", y esto sólo es recomendable para funciones cortas, ya que, (como recordarás), en estas funciones se inserta el código cada vez que son llamadas.

inline :- Las funciones miembro definidas dentro del cuerpo de la declaración de la clase se denominan definiciones de funciones en línea ( inline ). Para el caso de funciones más grandes, es preferible codificar sólo el prototipo de la función dentro del bloque de la clase y codificar la implementación de la función en el exterior. Esta forma permite al creador de una clase ocultar la implementación de la función al usuario de la clase proporcionando sólo el código fuente del archivo de cabecera, junto con un archivo de implementación de la clase precompilada.

Especificaciones de acceso:

Dentro de la lista de miembros, cada miembro puede tener diferentes niveles de acceso. En nuestro ejemplo hemos usado dos de esos niveles, el privado y el público, aunque hay más.

Acceso privado, private:

Los miembros privados de una clase sólo son accesibles por los propios miembros de la clase y en general por objetos de la misma clase, pero no desde funciones externas o desde funciones de clases derivadas.

Acceso público, public:

Cualquier miembro público de una clase es accesible desde cualquier parte donde sea accesible el propio objeto.

Acceso protegido, protected:

Con respecto a las funciones externas, es equivalente al acceso privado, pero con respecto a las clases derivadas se comporta como público.

Cada una de éstas palabras, seguidas de ":", da comienzo a una sección, que terminará cuando se inicie la sección siguiente o cuando termine la declaración de la clase. Es posible tener varias secciones de cada tipo dentro de una clase.

Si no se especifica nada, por defecto, los miembros de una clase son privados.

Aunque las secciones públicas, privadas y protegidas pueden aparecer en cualquier orden, los programadores suelen seguir ciertas reglas en el diseño que citamos a continuación, y que usted puede elegir la que considere más eficiente.

1. Poner los miembros privados primero, debido a que contiene los atributos (datos).

2. Poner los miembros públicos primero debido a que los métodos y los constructores son la interfaz del usuario de la clase.

En realidad, tal vez el uso más importante de los especificadores de acceso es implementar la ocultación de la información. El principio de ocultación de la información indica que toda la interacción con un objeto se debe restringir a utilizar una interfaz bien definida que permite que los detalles de implementación de los objetos sean ignorados. Por consiguiente, los datos y métodos públicos forman la interfaz externa del objeto, mientras que los elementos privados son los aspectos internos del objeto que no necesitan ser accesibles para usar el objeto.

El principio de encapsulamiento significa que las estructuras de datos internas utilizadas en la implementación de una clase no pueden ser  accesibles directamente al usuario de la clase.

Objetos

Una vez que una clase ha sido definida, un programa puede contener una instancia de la clase, denominada un objeto de la clase. Un objeto se crea de forma estática, de igual forma que se define una variable. También de forma dinámica, con el operador new aplicado a un constructor de la clase. El proceso de creación de un objeto con frecuencia se conoce como instanciar un objeto o creación de instancia del objeto. Por ejemplo, un objeto de la clase Punto inicializado a las coordenadas (2,1) :

Punto p1(2, 1);                               // objeto creado de forma estática
Punto* p2 = new Punto(2, 1);       // objeto creado dinámicamente


Formato para crear un objeto

NombreClase varObj(argumentos_constructor);

Formato para crear un objeto dinámico

NombreClase* ptrObj;
ptrObj = new NombreClase(argumentos_constructor);

El operador de acceso a un miembro del objeto, selector punto ( . ), selecciona un miembro individual de un objeto de la clase.

Por ejemplo:

El otro operador de acceso es el selector flecha ( -> ), selecciona un miembro de un objeto desde un puntero a la clase. Por ejemplo:

p = new Punto(2, -5);     // crea objeto dinámico

cout << " Coordenada y es " << p -> leerY();

Constructores

Un constructor es un método que se ejecuta de manera automática al instanciar un objeto de una clase. El constructor tiene como finalidad la incialización de las variables de la clase y posiblemente ejecutar algunos de los métodos de la clase. Una clase puede tener tantos constructores (sobrecargas) como el desarrollador lo estipule. La característica más sobresaliente de los constructores es que su nombre es el mismo que el de la clase, es decir, son métodos de la clase que se nombran igual que la clase, y que además no tienen valor de retorno. Las distintas sobrecargas del constructor de una clase van a depender de las distintas combinaciones de parámetros de entrada de la función. Cuando no se declara un constructor de manera explícita para una clase entonces C++ se encarga de asignar un constructor implícito por defecto a la clase, no tendría ningún sentido declarar un constructor como privado, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.

Añadamos un constructor a nuestra clase Persona:

revise los resultados de este programa y compararlos con el código del programa

Si una clase posee constructor, será llamado siempre que se declare un objeto de esa clase, y si requiere argumentos, es obligatorio suministrarlos.

Por ejemplo, las siguientes declaraciones son ilegales:

Y las siguientes declaraciones son válidas:

Cuando no especifiquemos un constructor para una clase, el compilador crea uno por defecto sin argumentos. Por eso el ejemplo anterior ha este, sin declarcion de constructor funcionaba correctamente. Cuando se crean objetos locales, los datos miembros no se inicializarían, contendrían la "basura" que hubiese en la memoria asignada al objeto.

No tienen tipo de retorno, y por lo tanto no retornan ningún valor.

Si se trata de objetos globales, los datos miembros se inicializan a cero.

Para declarar objetos usando el constructor por defecto o un constructor que hayamos declarado sin parámetros no se debe usar el paréntesis:

Se trata de un error frecuente cuando se empiezan a usar clases, lo correcto es declarar el objeto sin usar los paréntesis:

Destructores

El complemento a los constructores de una clase es el destructor. Así como el constructor se llama al declarar o crear un objeto, el destructor es llamado cuando el objeto va a dejar de existir por haber llegado al final de su vida. En el caso de que un objeto (local o auto) haya sido definido dentro de un bloque {…}, el destructor es llamado cuando el programa llega al final de ese bloque.

Si el objeto es global o static su duración es la misma que la del programa, y por tanto el destructor es llamado al terminar la ejecución del programa. Los objetos creados con reserva dinámica de memoria (en general, los creados con el operador new) no están sometidos a las reglas de duración habituales, y existen hasta que el programa termina o hasta que son explícitamente destruidos con el operador delete. En este caso la responsabilidad es del programador, y no del compilador o del sistema operativo.

A diferencia del constructor, el destructor es siempre único (no puede estar sobrecargado) y no tiene argumentos en ningún caso. Tampoco tiene valor de retorno. Su nombre es el mismo que el de la clase precedido por el carácter tilde (~), carácter que se consigue con Alt+126 en el teclado del PC. En el caso de que el programador no defina un destructor, el compilador de C++ proporciona un destructor de oficio, que es casi siempre plenamente adecuado (excepto para liberar memoria de vectores y matrices).

En el caso de que la clase Persona necesitase un destructor, la declaración sería así:

y la definición de la clase, añadiendo en este caso como variable miembro una cadena de caracteres que contenga el nombre del titular, podría ser como sigue, podemos colocarlo antes de main():

Como se realiza un destructor:

Inicialización de objetos:

Hay un modo simplificado de inicializar los datos miembros de los objetos en los constructores.

Se basa en la idea de que en C++ todo son objetos, incluso las variables de tipos básicos como int, char o float.

Según eso, cualquier variable (u objeto) tiene un constructor por defecto, incluso aquellos que son de un tipo básico.

Sólo los constructores admiten inicializadores. Cada inicializador consiste en el nombre de la variable miembro a inicializar, seguida de la expresión que se usará para inicalizarla entre paréntesis.

Los inicializadores se añadirán a continuación del paréntesis cerrado que encierra a los parámetros del constructor, antes del cuerpo del constructor y separado del paréntesis por dos puntos ":".

Por ejemplo, en el caso anterior de la clase "Persona":

Podemos sustituir el constructor por:

Sobrecarga de constructores:

Además, también pueden definirse varios constructores para cada clase, es decir, la función constructor puede sobrecargarse. La única limitación es que no pueden declararse varios constructores con el mismo número y el mismo tipo de argumentos.

Por ejemplo, añadiremos un constructor adicional a la clase "pareja" que simule el constructor por defecto:

De este modo podemos declarar objetos de la clase "pareja" especificando los dos argumentos o ninguno de ellos, en este último caso se inicializarán los datos miembros con ceros.

Consideremos el siguiente ejemplo para usar sobrecarga, de funciones, la restricción para la sobrecarga de métodos es que los mismos deben diferir en cantidad o tipo de parámetros. Es decir podemos definir dos métodos con el mismo nombre pero uno tenga por ejemplo 3 parámetros y otro tenga 2 parámetros:

//Sobrecarga de funciones miembro sobrecarga.cpp
#include<iostream>

using namespace std;

class Matematica {
public:
    int mayor(int x1,int x2);
    int mayor(int x1,int x2,int x3);
    float mayor(float x1,float x2);
    float mayor(float x1,float x2,float x3);
};

int Matematica::mayor(int x1,int x2)
{
    if (x1>x2)
        return x1;
    else
        return x2;
}

int Matematica::mayor(int x1,int x2,int x3)
{
    if (x1>x2 && x1>x3)
        return x1;
    else
        if (x2>x3)
            return x2;
        else
            return x3;
}

float Matematica::mayor(float x1,float x2)
{
    if (x1>x2)
        return x1;
    else
        return x2;
}

float Matematica::mayor(float x1,float x2,float x3)
{
    if (x1>x2 && x1>x3)
        return x1;
    else
        if (x2>x3)
            return x2;
        else
            return x3;
}

int main(int argc, char *argv[])
{
    Matematica m1;
    cout<<"Mayor entre 6 y 8 : ";
    cout<<m1.mayor(6,8);
    cout <<"\n";
    cout<<"Mayor entre 10, 40 y 5 : ";
    cout<<m1.mayor(10,40,5);
    cout <<"\n";
    cout<<"Mayor entre 6.2  y  9.3 : ";
    cout<<m1.mayor(6.2f,9.3f);
    cout <<"\n";
    cout<<"Mayor entre 7 , 12.5  y  4.2 : ";
    cout<<m1.mayor(7.0f,12.5f,4.2f);
    cout <<"\n";

    return 0;
}

Para CodeBlocks

Para NetBeans

Para CLI

Resumen de esta sección:

A continuación se definen las sintaxis en C++ de los conceptos esenciales de clases en la POO usando el lenguaje de programación C++

Declaración de una clase:

La sintaxis, para la declaración de clases, se expresa a continuación:

La lista de miembros será en general una lista de operaciones (métodos) y atributos (datos).

Los atributos se declaran del mismo modo en que lo hacíamos hasta ahora, salvo que no pueden ser inicializados.

Las operaciones pueden ser simplemente declaraciones de prototipos, que se deben definir aparte de la clase pueden ser también definiciones.

Cuando se definen fuera de la clase se debe usar el operador de ámbito "::".

El siguiente ejemplo muestra la declaración de la clase entero:

La clase Entero tiene un miembro de tipo de datos o atributo llamado valor y cinco operaciones, una para leerlo (setValor), uno para mostrarlo (getValor) y el resto para efectuar operaciones con él (sumar, restar e invAd). Nótese que su sintaxis es similar a la del tipo de datos definidos por struct.

Modificadores de acceso

Los modificadores son elementos del lenguaje que se colocan delante de la definición de variables locales, datos miembro, métodos o clases y que alteran o condicionan el significado del elemento en la cual cada miembro puede tener diferentes niveles de acceso. C++ tiene 3 modificadores de acceso para los miembros de las clases a saber:

public: Cualquier miembro público de una clase es accesible desde cualquier parte donde sea accesible el propio objeto.

private: Los miembros privados de una clase sólo son accesibles por los propios miembros de la clase y en general por objetos de la misma clase, pero no desde funciones externas o desde funciones de clases derivadas.

protected: Con respecto a las funciones externas, es equivalente al acceso privado, pero con respecto a las clases derivadas se comporta como público.

Cada una de éstas palabras, seguidas de ":", da comienzo a una sección, que terminará cuando se inicie la sección siguiente o cuando termine la declaración de la clase. Es posible tener varias secciones de cada tipo dentro de una clase.

Si no se especifica nada, por defecto, los miembros de una clase son privados.

Constructores y destructores

Los constructores

Los constructores son métodos especiales que sirven para inicializar un objeto de una determinada clase al mismo tiempo que se declara.

Los constructores son especiales por varios motivos:

1. Tienen el mismo nombre que la clase a la que pertenecen.

2. No tienen tipo de retorno, y por lo tanto no retornan ningún valor.

3. No pueden ser heredados.

4. Por último, deben ser públicos, no tendría ningún sentido declarar un constructor como privado, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.

Su sintaxis es:

La clase Entero, al añadir un constructor, quedaría así:

Al desarrollar el constructor este permite realizar instancias de objetos de tipo Entero siguiendo la siguiente sintaxis:

Constructor por defecto

Es un constructor sin parámetros inicialmente creado por el compilador de forma automática cuando a la clase no se le define un constructor de manera explícita.

Cuando se crean Objetos de forma local los atributos de estos tendrías valores al azar trayendo “basura” que hubiese en la memoria asignada al objeto. En cambio, si se tratan de objetos globales, dichos atributos se inicializarían en cero.

Para declarar objetos usando el constructor por defecto o un constructor que hayamos declarado sin parámetros no se debe usar el paréntesis.

Ejemplo:

Inicialización de objetos

En C++ las variables de tipos básicos como int, char o float son objetos. En C++ cualquier variable (u objeto) tiene, al menos un constructor, el constructor por defecto, incluso aquellos que son de un tipo básico.

Sólo los constructores de las clases admiten inicializadores. Cada inicializador consiste en el nombre del atributo a inicializar, seguida de la expresión que se usará para inicializarla entre paréntesis. Los inicializadores se añadirán a continuación del paréntesis cerrado que encierra a los parámetros del constructor, antes del cuerpo del constructor y separado del paréntesis por dos puntos ":".

Por ejemplo la implementación del constructor:

Quedaría así:

Sobrecarga de constructores

Los constructores son funciones, y por ende en C++, también pueden definirse varios funciones con el mismo nombre (en nuestro caso constructores) para cada clase, es decir, el constructor puede sobrecargarse. La única limitación (como en todos los casos de sobrecarga) es que no pueden declararse varios constructores con el mismo número y el mismo tipo de argumentos.

Por ejemplo, es posible agregar un constructor adicional a la clase Entero que simule el constructor por defecto:

Constructores con argumentos por defecto

También pueden asignarse valores por defecto a los argumentos del constructor, de este modo se reduce significativamente el número de constructores necesarios. La asignación se realiza en la definición del constructor

El ejemplo muestra la clase Entero haciendo uso de un constructor el cual tiene su único argumento por defecto y este valor es igual a cero.

Si la función main es la siguiente:

La salida fuera esta:

Ya que al no realizar las instancias de los objetos con valores, el compilador los inicializa de acuerdo a la definición del los argumentos por defecto presente en la definición del constructor, el cual es cero.

Funciones miembro constantes

Un método de una clase se puede declarar de forma que nos impida modificar el contenido del objeto (es decir, como si para la función el parámetro this fuera constante). Para hacer esto basta escribir la palabra después de la declaración de la función:

class empleado {
...
float cuanto_cobra (void) const;
...
};
float empleado::cuanto_cobra (void) const
{
return sueldo;
}

Las funciones miembro constantes se pueden utilizar con objetos constantes, mientras que las que no lo son no pueden ser utilizadas (ya que podrían modificar el objeto).

Usando el atributo protected:

Si no podemos copiar el valor, entonces podemos usar dos técnicas. Una es la de C mediante punteros.

La otra es con la expresión de C++ const_cast<TIPO>:const int constante = 5;

El atributo protected:

Los miembros protegidos son accesibles en la clase que los define y en las clases que heredan de esa clase.

Los miembros protegidos de una clase "A" no son accesibles fuera del código de "A", pero es accesible desde el código de cualquier clase derivada de "A".

Adelante veremos como nos ayuda protected para generar herencia.

La funcionalidad de esta clase esta soportada por los datos miembros privados mes, dia anio, y por funciones miembro AsignarFecha, ObtenerFecha, FechaCorrecta Bisiesto.

Del programa anterior sus resultados es:

Para CodeBlocks

Para NetBeans

Para CLI

Ámbito de clase

Cualquier función miembro de una clase puede acceder a otro miembro de su misma clase.

Los miembros privados de una clase, datos o funciones son locales a la misma y solo pueden ser accedidas por la funciones miembro de su clase o por una función friend de la misma clase.

Los miembros public locales son locales a la clase, pueden ser accedidos por funciones miembro de su clase y por cualquier otra función que defina un objeto o un puntero, a un objeto de esa clase,

Es decir un miembro publico de una clase es local a su clase y solo es accesible:

• A través de un objeto de su clase o de una clase derivada de esta utilizando el operador " . "

• A través de un puntero a un objeto de su clase o una una clase derivada de esta utilizando el operador "->"

• A través  del nombre de sus clase o de una clase derivada de esta utilizando el operador "::"

El puntero implícito this

Cada objeto de una clase mantiene su propia copia de los datos miembro de su clase, pero no de las funciones miembro, de los cuales solo existe una sola copia para todos los objetos de esa clase. Cada objeto tiene su propia estructura de datos, y comparten todos su codigo, para que una función miembro conozca la identidad del objeto particular para el cual dicha funcion ha sido invocada, C++ proporciona un apuntador llamado this, si declaramos un objeto fecha1 y enviamos un mensaje AsignarFecha.

C++ define un puntero this para permitir referirse al objeto fecha1 en el cuerpo de la función que se ejecuta como respuesta al mensaje.

Incluiremos un constructor en el programa anterior

Para CodeBlocks

Para NetBeans

Para CLI

para que se vea mas claro este asunto observe el siguiente programa, y su resultado:

//programa clase_4a.cpp usando un constructor definido
#include <iostream>
#include <string>
using namespace std;
class Fecha
{
    private:
        int dia,mes,anio;

    public:
        Fecha(int dia,int mes,int anio); //definicion del constructor
        //la funcion miembro siguiente se puede acceder fuera de la clase
        // usando apuntadores de memoria y de forma const y void de retorno
        void mostrar_fecha(int *,int *,int *) const;
};

//constructor
Fecha::Fecha(int _d,int _m,int _a)
{
dia=_d,mes=_m,anio=_a;
std::cout << "Inicia Constructor de fecha con :"<<dia<<"/"<<mes<<"/"<<anio<<std::endl;
//al llegar al constructor muestra el mensaje que llego hasta aqui
}

void Fecha::mostrar_fecha(int *pd,int *pm,int *pa) const
{
//muestra valores asignados en el constructor
std::cout << "funcion mostrar fecha "<< dia <<"/"<< mes<<"/"<<anio<<" ";
}
// Funciones prototipo que estan afuera de la clase, que no son funciones miembro
// tipo void const que es del tipo de la funcion miembro mostrar_fecha, const clase Fecha y una direccion de memoria &f
void VisualizarFecha(const Fecha &f);

// Visualizar una fecha
void VisualizarFecha(const Fecha &f)
{
    int dd,mm,aa;
    f.mostrar_fecha(&dd,&mm,&aa);//realiza el llamado a al función miembro mostrar_fecha
}


int main(int argc,char *argv[])
{
//creacion de objetos en la misma clase Fecha
Fecha dia_festivo(11,06,21); //crea el objeto y por la definicion de clase y lo lleva al constructor
Fecha Navidad(12,25,21);
Fecha Hallowen(10,31,21);
Fecha Septiembre_independencia(9,15,21);
Fecha Anio_nuevo(12,31,21);
Fecha cumpleanios(06,11,21);
//llamada a la funcion para visualizar los valores de lo objetos
VisualizarFecha(dia_festivo),std::cout <<"Dia festivo "<<std::endl;
VisualizarFecha(Navidad),std::cout <<"Dia Navidad "<<std::endl;
VisualizarFecha(Hallowen),std::cout <<"Dia Hallowen "<<std::endl;
VisualizarFecha(Septiembre_independencia),std::cout <<"Dia independecia "<<std::endl;
VisualizarFecha(Anio_nuevo),std::cout <<"Dia año nuevo "<<std::endl;
VisualizarFecha(cumpleanios),std::cout <<"Dia cumpleaños"<<std::endl;

}

Para CodeBlocks

Para NetBeans

Para CLI

Cuando una clase tiene un constructor, este sera invocado automaticamente siempre que se cree un nuevo objeto de esta clase. Si el constructor tiene argumentos estan deberan de especificarse en una lista de valores entre parentesis:

Hay otra manera de iniciar el constructor

Ahora el Cosnstructor definido con argumentos por omision admite llamadas con 0, 1, 2, o 3 argumentos

Define un objeto hoy e inicializa sus datos miembro dia, mes y anio, a los valores 11 06 2021. Para ello se invoca el constructor

Esto es llamada explicita al constructor, ha sustituido al llamado implícito del constructor, al ejecutarse CFecha Otrodia; marcara un error ya que hace llamada al constructor sin argumentos, para solucionar esto debemos hacer llamada al constructor por omisión, de la siguiente forma:

En este ejemplo se ha hecho el constructor sin argumentos, esto hace que la linea

invoque a los constructores por omisión para cada uno de los miembros del objeto Otrodia

podemos definir diferentes constructores con el mismo nombre y diferentes argumentos, con el fin de poder inicializar objetos con diferentes formas.

Considerando lo anterior el constructor podemos decir que el constructor puede quedar asi:

Retomemos el apuntador this, para que nos quede claro el funcionamiento de this.

En otras palabras podemos decir que, podemos crear varios objetos de una clase. Cada objeto tiene una copia en memoria de todos los atributos (variables) que son independientes de los otros objetos. En el lenguaje C++ para poder identificar a que objeto en particular estamos accediendo cuando llamamos a un método se le pasa un parámetro llamado this (significa este objeto).

Veamos con un ejemplo donde aparece este puntero:

Podemos ver que cada vez que accedemos a un atributo o llamamos en un método dentro de la clase le antecedemos el puntero this.

Este puntero almacena la dirección de memoria donde se guardan los atributos del objeto respectivo, por ejemplo cuando en la main creamos un objeto de la clase Temperatura:

Al constructor ademas de pasar los tres enteros 10, 20 y 15 se le pasa un cuarto parámetro que es la dirección de memoria donde se almacenan los atributos del objeto "temperatura1".

Luego dentro del constructor cuando escribimos:

Cuando se ejecuta este código this tiene la dirección del objeto temperatura1 o temperatura2 según el caso.

También cuando llamamos a un método dentro de la clase estamos antecediendo el puntero this para saber de cual objeto se trata:

Pero ¿porqué no lo hemos estado haciendo hasta ahora? Es que no es obligatorio anteceder a los nombres de atributos y métodos, pero en realidad la dirección de los atributos de cada objeto en C++ se resuelve mediante este puntero.

Ya veremos casos en conceptos sucesivos donde es muy importante utilizar este puntero this explícitamente.

Un caso muy sencillo donde debemos utilizar el puntero this obligatorio es cuando un método tiene parámetros con el mismo nombre que los atributos de la clase.

Para CodeBlocks

Para NetBeans

Para CLI

*****************************************************************************************************************************************************************

Asignacion de Objetos

Otra forma de asignar objetos es usando el operador =.

Esto define los objetos hoy y Otrodia la asignación se hace de miembro a miembro, cuando se hace asignación no se construye objeto, si no que ambos existen:

La funcion retorna una referencia al objeto resultante lo que genera que se puedan hacer asignaciones multiples (a=b=c)

Constructor copia, una nueva copia de un objeto a partir de otra existente, tiene un solo argumento, el cual hace refereferencia a un objeto constante de la misma clase, y no hay valor de retorno:

Tambien posible reescribir la asignación como:

Para CodeBlocks

Para NetBeans

Para CLI

Para escribir salida a un archivo (es decir de los datos en RAM que usa el programa y enviarlos al disco, con un nombre)  se debe de crear un objeto ofstream en seguida se debe abrir el archivo usando la función miembro open cuando se han escrito los datos debemos cerrar el archivo, usando la función miembro close.

Comenzamos con ejercicios simples y fáciles he iremos aumentando las características y formas.

// file_out.cpp
//programa escritura datos en texto

// este programa creara un archivo que recibiría datos desde el programa y los guarda en disco,
//en un archivo

#include <fstream>
using namespace std;

int main(int argc, char* argv[])

{
    ofstream archivo_salida; //crea el objeto archivo_salida
    archivo_salida.open("libros.dat");//Crea y Abre el archivo de salida libros.dat
   
    archivo_salida <<"Titulo: Exito con C++" <<endl;
    archivo_salida <<"Autor: Yo he llegado muy lejos con C++"<<endl;
    archivo_salida <<"Editorial Mi esfuerzo"<<endl;

    archivo_salida.close();
    return 0;
}

NOTA: CUANDO SE REALICE EN CODEBLOCK O APACHE NETBEANS, UBICAR EL DIRCTORIO DONDE SE REALIZO LA COMPILACION Y EJECUTAR EL PROGRAMA Y REVISAR EL DIRECTORIO, DEBERA DE MOSTRAR EL ARCHIVO DE DATOS .DAT.

Para CodeBlocks

Para NetBeans

como no podemos ver directamente el producto de Apache NetBeans lo revisamos desde su directorio de proyectos (libros.dat):

Para CLI

Usar funciones miembro de salida y manipuladores

Cuando los programas realizan operaciones (flujos)  en archivos, se pueden usar los manipuladores de salida, en el siguiente programa file_out1.cpp, crea un archivo de datos llamado file_out_data1.dat, que contendrá las representaciones en Decimal, Octal y Hexadecimal, del 1 al 255. Para usar los manipuladores debemos usar la bliblioteca de encabezados "iomanip.h":

//programa file_out1.cpp

Para CodeBlocks

Para NetBeans

NOTA: CUANDO SE REALICE EN CODEBLOCK O APACHE NETBEANS, UBICAR EL DIRCTORIO DONDE SE REALIZO LA COMPILACION Y EJECUTAR EL PROGRAMA Y REVISAR EL DIRECTORIO, DEBERA DE MOSTRAR EL ARCHIVO DE DATOS .DAT.

Para CLI

Se puede usar la función miembro put para agregar caracteres en el archivo de datos (archivo de salida), el programa escribiría los caracteres en el archivo de salida file_out_data2.dat, que el programa file_out2.cpp genera:

// programa file_out2.cpp

//autor:
//fecha

#include "fstream"

using namespace std;
int main(int argc,char* argv[])
{
    ofstream alfabeto ("file_out_data2.dat");
        // genera/abre el archivo file_out_data2.dat 

    for(int letra = 'A'; letra <= 'Z'; letra++)
    {alfabeto.put((char)letra);}

alfabeto.close();

    return 0;
}

Para CodeBlocks

Para NetBeans

NOTA: CUANDO SE REALICE EN CODEBLOCK O APACHE NETBEANS, UBICAR EL DIRCTORIO DONDE SE REALIZO LA COMPILACION Y EJECUTAR EL PROGRAMA Y REVISAR EL DIRECTORIO, DEBERA DE MOSTRAR EL ARCHIVO DE DATOS .DAT.

Para CLI

El siguiente programa realiza lo mismo pero usando el operador de inserción.

#include "fstream"
using namespace std;

int main(void)
{
    ofstream alfabeto("file_out_data3.dat");

    for(char letra = 'A'; letra <= 'Z'; letra ++)
    {alfabeto << letra;}

}

Para CodeBlocks

Para NetBeans

NOTA: CUANDO SE REALICE EN CODEBLOCK O APACHE NETBEANS, UBICAR EL DIRCTORIO DONDE SE REALIZO LA COMPILACION Y EJECUTAR EL PROGRAMA Y REVISAR EL DIRECTORIO, DEBERA DE MOSTRAR EL ARCHIVO DE DATOS .DAT.

Para CLI

Antes de continuar debemos recordar esto:

setw(n)  donde n es un numero entero positivo

- Modifica la anchura de campo únicamente para la siguiente entrada o salida. Por defecto es 0, pero se expande cuanto sea necesario. ejemplo :

i=3;
cout << setw(10) << i << endl;

setprecision(n) donde n es un numero entero positivo

Establece la precisión decimal que se utilizará para dar formato a los valores de coma flotante en las operaciones de salida, ejemplo :

double f =3.14159;
  std::cout << std::setprecision(5) << f << '\n';
  std::cout << std::setprecision(9) << f << '\n';

setiosflags() se utiliza para establecer los indicadores de formato. (formar una mascara, un formato de presentación), ejemplo:

cout << "|" << 5 <<"|";
cout << "|" << setw(4) << 5 << "|";
cout << "|" << setw(5)  << setiosflags(ios::fixed) << setprecision(2)  << 534.264 << "|";

como resultado:

|5|
|    5|
|534.26|

Ahora podemos utilizar esto para salida de datos a archivo con formato:

//programa file_out4.cpp

#include "fstream"
#include <iomanip>

using namespace std;

int main(void)
{
    ofstream reporte("file_out_data4.dat");

    struct {
        char nombre[64];
        int edad;
        char seguro[64];
        float sueldo;
    } empleados[] = {{"Roberto López",51,"1111111",5500.00},
             {"Erendira López",43,"222222",6000.00},
             {"Regina Pérez",30,"333333",7000.00}};

    reporte << "Nombre\t\tedad\tSeguro\t\tSueldo" <<endl;

    for (int i=0;i<3;i++)
    {
      reporte << setiosflags(ios::left) << setw(18)<< empleados[i].nombre << setw(8) <<empleados[i].edad << setw(16)<< empleados[i].seguro
<< setprecision(2) << setiosflags(ios::showpoint|ios::fixed) << empleados[i].sueldo << endl; // la secuencia es en una sola linea
    }
reporte.close();
return 0;
}

Para CodeBlocks

Para NetBeans

NOTA: CUANDO SE REALICE EN CODEBLOCK O APACHE NETBEANS, UBICAR EL DIRCTORIO DONDE SE REALIZO LA COMPILACION Y EJECUTAR EL PROGRAMA Y REVISAR EL DIRECTORIO, DEBERA DE MOSTRAR EL ARCHIVO DE DATOS .DAT.

Para CLI

Control de apertura de archivos de salida

Dependiendo del propósito del programa en ocasiones se desea que se agreguen datos al archivo de salida, es decir al final del mismo, o en ocasiones no usar un archivo de datos que ya existe para evitar borrar y perder la información.

Se puede controlar la forma de apertura de los archivos de datos, se puede especificar la forma de apertura:

ofstream output("archivo.dat", ios::app);

ios::app Abre el archivo para añadir informacion.

si existe "archivo.dat" lo abre para añadir datos, si no existe lo genera.

El siguiente programa crea el archivo de datos y agrega información.

//programa file_out5.cpp
//Toma la fecha y la hora del sistema
//usa un manipulador y va agreagando al archivo file_out_data5.dat
//la  fecha y hora en cada ocacion que se ejecuta el programa
//demostrando que el ios::app, agrega datos al archivo de datos

#include "fstream"
#include <iomanip>
#include <ctime>
using namespace std;

int main(int argc, char* argv[])
{
    ofstream archivo_salida("file_out_data5.dat",ios::app);


    auto t = time(nullptr);
    auto tm = *::localtime(&t);
    // Cuando se usa en una expresión put_time(tmb, fmt)
    // convierte la información de fecha y hora de una hora del calendario determinada tmb
    // a una cadena de caracteres según la cadena de formato fmt

    archivo_salida << put_time(&tm, "%d-%m-%Y %H-%M-%S") << endl; //el manipulador envia directo al archivo_salida
    //                          ^           ^
    //                put_time          (tmb, fmt)

    // put_time es un stream manipulador, así que también puede utilizarse junto a stringstream para
    // convertir una fecha en una cadena de caracteres:

    stringstream oss;
    oss << put_time(&tm, "%d-%m-%Y %H-%M-%S"); // aqui no se usan apuntadores, pero oss recibe el "formato" de put_time
    auto str = oss.str(); // lo pasa a string y lo instancia a str
    archivo_salida << str; // y str es asignado a achivo_salida

    archivo_salida<<endl;
    archivo_salida.close();  // tendremos 2 formatos de fecha en el archivo_salida

return 0;
}

Para CodeBlocks

Para NetBeans

Para CLI

Si esperamos un rato para que el reloj avance y ejecutamos de nueva cuenta file_out5, tomara el nuevo valor fecha/hora y lo agregara al archivo file_out_data5.dat

Debemos de observar que los datos que se agregan iran quedando en la parte inferior

La función miembro open usa varios especificadores.

Al especificar la apertura de un archivo como se ha mostrado en los programas anteriores, el programa sobreescribe cualquier archivo existente, en el directorio de trabajo del programa. Dependiendo del propósito del programa es posible que sea necesario agregar datos a los ya existentes en el archivo, o quizá sea necesario que las operaciones del programa no se lleven a cabo en caso de que el archivo especificado exista en el disco, para éstos casos podemos especificar el modo de apertura del archivo incluyendo un parámetro adicional en el constructor, cualquiera de los siguientes:

ios::app Operaciones de añadidura.

ios::ate Coloca el apuntador del archivo al final del mismo.

ios::in Operaciones de lectura. Esta es la opción por defecto para objetos de la clase ifstream.

ios::out Operaciones de escritura. Esta es la opción por defecto para objetos de la clase ofstream.

ios::nocreate Si el archivo no existe se suspende la operación.

ios::noreplace Crea un archivo, si existe uno con el mismo nombre la operación se suspende.

ios::trunc Crea un archivo, si existe uno con el mismo nombre lo borra.

ios::binary Operaciones binarias.

Operaciones de control archivo de entrada

Para abrir un archivo de entrada (es del disco a la memoria RAM, que esta usando el programa), se crea un objeto del tipo ifstream

El siguiente programa abre un archivo de datos (.dat) desde la linea de comandos:

//programa file_in.cpp
#include "fstream"
#include "iostream"
using namespace std;

int main(int argc, char** argv)

{

    ifstream  entrada(argv[1]);
  
        if (entrada.fail())

        {cerr << "Error al abrir el archivo  :" << argv[1] <<endl;}

         else
        {
            while (! entrada.eof()) //lee caracteres en el archivo cuando encuentra el eof se detiene y cierra el archivo
                cout.put((char)entrada.get()); //muestra el caracter

          entrada.close();
}
    cout << endl;
return 0;      
}

Para CodeBlocks

Al crear el programa pero nos presentara error en Code:Block porque espera un argumento de entrada, cualquier archivo de datos .dat creados anteriormente, para solucionar el problema usaremos el botón de compilación únicamente y creara el ejecutable en el directorio:

ya escrito el programa en code:blocks solo lo compilamos, primero revisemos la carpeta donde se generan los ejecutables:

se compila con esto, genera el ejecutable:

el icono que tiene la forma de engrane

y se observa lo siguiente en el directorio:

observamos el código fuente, y a la izquierda el ejecutable

Para NetBeans

podemos observar que muestra errores pero si es posible compilar y ejecutar dando por resultado Error al abrir el archivo:

en el directorio se genera el ejecutable.

Para CLI

En este caso no muestra problemas ni Warning este es el ejemplo como debemos usarlo en los anteriores ya sea copiando el ejecutable al directorio donde se encuentran los archivos de datos .dat o viceversa.

Los programas precedentes han usado la función miembro fail para determinar si fallo o tubo éxito la apertura del archivo de datos .dat, las funciones miembro tambien pueden ser de la siguiente manera:

Función miembro	Proposito
good	Produce 1 si la operación previa fue exitosa
eof	Produce 1 si llego al final del archivo de datos
fail	Produce 1 cuando hay un error
bad	Produce 1  si se produce una operación invalida

Podemos decir entonces que:

if(entrada.fail())    y  if( ! entrada)

son similares

De igual manera:

if(entrada.good())   y   if(entrada)

son similares en el resultado

Operaciones en archivos de datos binarios.

Cuando se lee un achivo de datos de modo texto se considera que el el valor 26 de ASCII (Crtl Z) es el final del archivo, si se intenta leer un archivo binario de datos es muy probable que en cualquier lugar se encuentre el ASCII 26,provocando que termine la lectura antes de lo que esl final real del archivo.

Para evitar esto debemos abrir el archivo de forma binaria:

ifstream entrada(argv[1],ios..binario);

En seguida , necesitamos las operaciones para entrada y salida, con las funciones miembro

entrada.read(buffer, sizeof(buffer));
entrada.write(buffer, sizeof(buffer));

 

El siguiente programa escribira 30 datos de tipo numerico, de punto flotante, que es la manera adecuada de guardar datos numericos

Para CodeBlocks

Para NetBeans

Para CLI

Para verificar esto deberán de ingresara a cada directorio donde se estan generando estos archivos de datos y verificarlos con cat en LINUX y type en windows

El programa invoca la función miembro .write, pasando la dirección del valor a donde escribira al archivo:

Estos archivos de datos no pueden se leídos como texto porque esta en binario, para leerlos debemos usar el siguiente programa:

Para CodeBlocks

Para NetBeans

Para este caso hay que solucionar un detalle el archivo que debemos leer no estará en este directorio, y lo que se realiza es que se leen los archivos desde el directorio actual por lo cual, debemos copiar el archivo de datos binario desde le proyecto  file_in1  hacia el proyecto file_in2, esto se hace desde el administrador de archivos o desde linea de comandos:

de otra forma regresara 0.00 en un loop infinito ya que no encuentra el EOF.

Para CLI

El resultado es muy extenso asi que realizamos pausa por pantalla para ver resultado:

Operaciones de inserción y extracción de archivos de datos en binario

Para realizar operación de inserción y extracción en binarios usamos read y write, se  pueden encontrar errores inesperados , cuando se manipulan los datos, de binario al pasar a ASCII, POR LOS VALORES QUE REPRESENTAN,consideremos el siguiente programa:

// programa datos_mal.cpp
#include "fstream"

using namespace std;

Para CodeBlocks

Para NetBeans

Para CLI

Ahora el siguiente programa lee estos datos mostrando los valores leídos y los datos que debieran ser

Para CodeBlocks

Para NetBeans

Al igual que en el caso anterior tenemos un detalle en la lectura de datos aquí, puesto que son proyectos distintos debemos copiar el archivo de datos .dat del anterior a este proyecto, primero realizamos el proyecto ya que no existe el directorio y luego copiamos el archivo .dat

Para CLI

Como podemos observar no son los resultados que esperamos y la razón es la siguiente, cuando se almacenan datos de forma binaria en el disco, estos tiene un diseño, un tanto cuanto especifico, y hasta ahi esta bien pero al recuperarlos (leerlos) deben pasar a ASCII, y ahi es cuando se presenta el problema, a continuación veremos la forma correcta de realizar esto, debemos de sobrecargar los operadores read y write, usaremos el tipo de inserción hidefloat

Antes de abrir un fichero hay que crear un flujo, es decir un objeto de las clases ifstream, ofstream o fstream e indicar el modo de apertura (lectura, escritura, lectura y escritura, …).

Los modos en los que se puede abrir un fichero son:

ios::append     //añadir datos al final del fichero

ios::in             //abrir fichero para leer datos

ios::out          //abrir fichero para escribir datos

en el siguiente ejemplo para usar un archivo de datos de tipo binario se debe usar 1 solo argumento (ios::out   ios::in  ios::append)

ostream& operator<<(ostream& archivo,hidefloat valor)    ostream::operator<<

Este operador ( <<) aplicado a un flujo de salida se conoce como operador de inserción . Está sobrecargado como función miembro para:

(1) tipos aritméticos

Genera una secuencia de caracteres con la representación de val , formateada correctamente según la configuración regional y otras configuraciones de formato seleccionadas en la secuencia, y los inserta en la secuencia de salida.

ejemplos:

ostream& operator<< (bool val);
ostream& operator<< (short val);
ostream& operator<< (unsigned short val);
ostream& operator<< (int val);
ostream& operator<< (unsigned int val);
ostream& operator<< (long val);
ostream& operator<< (unsigned long val);
ostream& operator<< (float val);
ostream& operator<< (double val);
ostream& operator<< (long double val);
ostream& operator<< (void* val);
ostream& operator<< (streambuf* sb );

(2) buffers de flujo

Recupera tantos caracteres como sea posible de la secuencia de entrada controlada por el objeto de búfer de secuencia (si lo hay) y los inserta en la secuencia, hasta que se agota la secuencia de entrada o hasta que la función no se inserta en la secuencia.

ejemplos:

(3) manipuladores
Llamadas pf(*this), donde pf puede ser un manipulador .
Los manipuladores son funciones diseñadas específicamente para ser invocadas cuando se usan con este operador.
Esta operación no tiene ningún efecto en la secuencia de salida y no inserta caracteres (a menos que el propio manipulador lo haga, como  endl ó ends

ejemplos:

Cada ocacion que el compilador encuentra un valor de tipo hidefloat usando con el operador de insercion y un flujo de archivo de salida, el programa llama a la función operator el cual usa la funcion miembro write para escribir el valor binario en el archivo de datos .dat

Para CodeBlocks

como resultado se aprecia caracteres que son en cierta forma incomprensibes pero es lo que escribe en el disco

Para NetBeans

Para CLI

Para leer el archivo binario usamos esto:

compárese con el programa que escribe datos al disco:

el que extrae datos del disco

Puedes identificar los que es diferente y que es lo que es similar.

Se concluye que:

Para abrir un fichero para lectura de datos creando un fstream fichero:

ifstream <entrada>("datos.dat", ios::in);

y para escritura en ese mismo fichero:

ofstream <salida>("datos.dat", ios::out);

Las clases ifstream, ofstream y fstream tienen también constructores que permiten abrir ficheros de forma automática ifstream <fichero>("datos.dat");

donde se sobreentiende que el fichero se abre para lectura por haber utilizado ifstream. Si se hubiese utilizado ofstream el fichero se hubiera abierto para escritura.

Para CodeBlocks

Para NetBeans

Al igual que en el caso anterior tenemos un detalle en la lectura de datos aquí, puesto que son proyectos distintos debemos copiar el archivo de datos .dat del anterior a este proyecto, primero realizamos el proyecto ya que no existe el directorio y luego copiamos el archivo .dat

Para CLI

En este caso cuando el programa encuentra un apuntador a una variable de tipo hidefloat  usado en el operador de extracción  y un flujo de entrada de archivo el programa llama a la  función de operador. Debido a que  la función debe de cambiar el valor de un miembro de la estructura, la dirección de la estructura  se pasa a la función, es un proceso posible de realizar pero es confuso de realizar sin embargo los datos se encapsulan y no son visibles como los archivos en ASCII.

Apertura de archivos para operaciones de Lectura y Escritura

En los ejemplos anteriores se han "abierto" archivos para escritura o lectura de datos, tambien conocidos secuenciales ya que se van agregando datos al final del archivo de datos.

Cuando se crean programas, lo que es usar archivos de datos para escritura/lectura de datos, para esos casos usaremos fstream

Cuando se abre un archivo para entrada y salida de datos el programa mantiene 2 apuntadores, uno para entrada y otro para salidas, y estos archivos de datos son usados para acceso aleatorio, estos no inician desde el principio, el programa puede "moverse" entre los diferentes registros, para este propósito se usan las funciones miembro seekg y seekp.

La función seekg coloca el apuntador en algún valor especifico dentro del archivo de datos, (seekg proviene de seek "busqueda" y g de get "obtener", la función seekp para operación de salida (seek "buscar" y p de put "colocar")

la sintaxis es:

seekg(despalzamiento, desde_la_posición)

seekp(despalzamiento, desde_la_posición)

desplazamiento es la cantidad de bytes que se movera en un archivo sea positivo o negativo, y desde_la_posicion es el lugar donde parte la búsqueda.

Este programa creara el archivo de datos: letras.dat

Para CodeBlocks

Para ver el contenido del archivo generado:

Para NetBeans

Para ver el contenido del archivo generado:

Para CLI

Para ver el contenido del archivo generado:

El siguiente programa prepara al archivo de datos "letras.dat" para operación de lectura y escritura(fstream letras("letras.dat",ios::in | ios::out);), para comenzar el apuntador se coloca en la posición de byte que sigue a la letra H, luego se escriben en el las letras I a Z. Enseguida el apuntador de entrada get se coloca al inicio del archivo lee y presenta el contenido.

// programa archiv_aleatorio_2.cpp
#include "fstream"
#include "iostream"

using namespace std;

int main(int argc,char * argv[])
{
  // las siguintes lineas dan un espacio al inicio
   cout << endl;
    system ("cat letras.dat");// realiza una llamada al sistema operativo y ejecuta el comado cat para mostrar el contenido
                                          // del archivo creado anteriormente antes de ser alterado desde la posicion
  cout <<endl;

   fstream letras("letras.dat",ios::in | ios::out);
  letras.seekp(8, ios::beg);
 
 for(char letra='I' ;letra <= 'Z'; letra++)
 letras<<letra;

 letras.seekp(0, ios::beg);
 
while( !letras.eof())
  cout.put((char)letras.get());//presenta el archivo modificado hasta el final del archivo eof()

letras.close();

return 0;
}

Para CodeBlocks

Para NetBeans

Al igual que en el caso anterior tenemos un detalle en la lectura de datos aquí, puesto que son proyectos distintos debemos copiar el archivo de datos .dat del anterior a este proyecto, primero realizamos el proyecto ya que no existe el directorio y luego copiamos el archivo .dat

Para CLI

para el siguiente programa necesitamos 2 archivos de datos, usaremos el programa archiv_aleatorio_1.cpp, el cual modificaremos un poco para ver el contenido de la salida y lo llamaremos archiv_aleatorio_1_a.cpp

y este mismo con el nombre de archiv_aleatorio_1_b.cpp esta modificacion:

//programa archiv_aleatorio_1_b.cpp
#include "fstream"
#include "iostream"

using namespace std;

int main(int argc, char* argv[])
{
    ofstream salida("letrasmin.dat");

    for(char letra ='a' ; letra  <='h' ; letra++ )
    salida << letra;
 
    for(char letra = 'o';letra <='z'; letra++)
    salida << letra;

    salida.close();
cout << "El archivo de datos contine lo siguiente :"<<endl;
system("cat letrasmin.dat");// mostrara las letras en minusculas
cout << endl;
return 0;
}

Los programas pueden controlar como se abren los archivos usando los especificadores de modo de apertura. En el siguiente programa es al forma de manejar los datos con archivos aleatorios: