Manejo de archivos

Introducción a Métodos de lectura y escritura en Archivos de acceso aleatorio. Antes de avanzar con las funciones que permiten escribir y leer vamos a recordar algo de
punteros.

Puntero y const

• Los punteros son variables que guardan una dirección de memoria.
  
• Los punteros son variables especiales por no tener sólo un valor (dirección de memoria), pero también tienen  asociado el valor a que apuntan: tipo de la variable.
• Como cualquier variable su valor puede ser constante o no. 
• La palabra clave const declara que un valor no es modificable por el programa.
• No puede hacerse ninguna asignación posterior a un identificador especificado como const , tira Error! 

const char

El tipo “const char” es una constante char  y el valor no puede ser cambiado por lo tanto SIEMPRE debe tener un valor al inicializar, ya que luego no se puede modificar, mientras que una variable , si puede ser cambiado.

Veamos unos ejemplos con const:

Puntero Constante a cadena de Carateres.

Regla práctica : Lo que está a la izquierda de const vale. Si no hay nada a la izquierda, vale lo que está a la derecha.

Vamos a tratar de entender  que es esta declaración:

char * const pt1; 

Miramos a la izquierda de const.

char * const pt1;
       ^^^^^

Vemos * =>  puntero.

char * const pt1;
     ^

Se debe interpretar como : puntero constante

Seguimos hacia la izquierda vemos char :

char * const pt1;
^^^^

Resultado:

pt1 es un puntero constante a char

• Puedo cambiar el contenido de lo apuntado, el char NO es constante.
• NO puedo modificar el puntero , el puntero si es constante.

char texto[] = "Sol";
char * const pt1 = texto; 
cout << *pt1 << endl;   // S
pt1[0] = 'T';           // OK
// pt1++;               // ERROR No puedo cambiar una constante

Puntero a cadena de caracteres constante

Regla práctica : Lo que está a la izquierda de const vale. Si no hay nada a la izquierda, vale lo que está a la derecha.

Vamos a tratar de entender  que es esta declaración:

const char * pt2;

Miramos a la izquierda de const  y no hay nada

const char * pt2;

 Pero a la derecha está const está char:  caracteres constantes.

Seguimos leyendo:

const char * pt2;
           ^

Vemos:  * o puntero!

→ puntero a caracteres constantes.

Resultado:

pt2 es un puntero a caracteres constantes.

• Puedo cambiar el puntero.

• NO puedo modificar el contenido apuntado, por que es constante.
  
  

char texto1[] = "Sol";     //cadena de caracteres
char texto2[] = "Luna";    //otra cadena de caracteres
const char * pt2 = texto1;  //puntero o  cadena constante de caracters 
cout << *pt2 << endl;      // muestra S
pt2 = texto2;              // OK, puedo cambiar el puntero
cout << *pt2 << endl;      // muestra L
// pt2[0] = 'M';           // ERROR , no puedo cambiar el contenido, es constante
// *pt2 = 'M';             // ERROR , no puedo cambiar el contenido, es constante

Sobre el nombre de un arreglo.

El nombre de un arreglo se comporta de manera similar a un puntero constante: puede usarse para acceder a los elementos, pero no puede hacerse que apunte a otro lugar.

char texto[] = "Sol";  //arreglo de caracteres, texto es un puntero al 1er caracter
char * const p = texto; //p apunta al primer caracter, por que texto apuntaba al 1er caracter.

// a la izquierda de const está * , por lo tanto p es un puntero constante, NO se puede modificar.
// Ambos permiten:
cout << texto[0]; // muestro el contenido , mostraría S
cout << p[0]; //muestro el contenido , mostraría S
// Ninguno permite:
texto++; // ERROR , el nombre del arreglo se comporta como un puntero constante.
p++;     // ERROR (porque p es const)

¿entonces por qué no es un puntero constante?

Porque su tipo real es diferente.

char texto[] = "Sol";
char * const p = texto;

Tipos:

texto   --> char[4]
p       --> char * const

Uno es un arreglo y el otro es un puntero. El compilador los trata de manera distinta.

Por ejemplo , sizeof(texto)  devuelve: 4 , porque mide el tamaño completo del arreglo.

Mientras que  sizeof(p) en una máquina de 64 bits suele devolver: 8 ,  porque mide el tamaño del puntero.

Notat que sería la mismo declarar :

• const char * : puntero a caracter constante.
• char const * : puntero a caracter constante.

Según la regla práctica , ambas declaraciones sería no mismo. 

Se suele recomendar escribir  “const char *”  para favorecer la comprensión . Así, cuando leés “const char *”, entendés de inmediato que los caracteres son constantes.  En resumen, la forma más clara y menos propensa a confusiones es colocar “const” justo al lado del elemento que querés proteger: char. E

Código para analizar por parte del alumno

Se deja al alumno pensar observar el siguiente código y justificar :

• que tipo de dato es pt1?
• que tipo de dato es pt2?
• por que pt1++  tiraría error?