Wiki CC3301

Herramientas de usuario

Herramientas del sitio

Estás aquí: start » punteros
Traza: • punteros
punteros

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Ambos lados, revisión anteriorRevisión previa
Próxima revisión		Revisión previa
punteros [2014/03/27 13:12] – [Cast de punteros] lmateupunteros [2021/09/22 20:07] (actual) – [Big endian vs. Little endian] lmateu
Línea 1: Línea 1:
-===== Punteros =====+====== Punteros ======
  
 Además del identificador de las variables globales o automáticas, también se puede identificar una variable por su //dirección// o //referencia//.  Corresponde a la dirección del primer byte que ocupa en memoria.  Es decir la menor de las direcciones de los bytes que conforman la variable.  En C es posible obtener la dirección de cualquier variable usando el operador unario de prefijo '&'.  Para que sea útil esta dirección, se requiere almacenarla en alguna variable.  Estas variables se denominan punteros.  Por ejemplo: Además del identificador de las variables globales o automáticas, también se puede identificar una variable por su //dirección// o //referencia//.  Corresponde a la dirección del primer byte que ocupa en memoria.  Es decir la menor de las direcciones de los bytes que conforman la variable.  En C es posible obtener la dirección de cualquier variable usando el operador unario de prefijo '&'.  Para que sea útil esta dirección, se requiere almacenarla en alguna variable.  Estas variables se denominan punteros.  Por ejemplo:
Línea 16: Línea 16:
 Para no entrar a usar valores numéricos de la direcciones en memoria graficaremos una dirección simplemente como una flecha hacia la variable de destino.  Diremos que el puntero p apunta a la variable v. Para no entrar a usar valores numéricos de la direcciones en memoria graficaremos una dirección simplemente como una flecha hacia la variable de destino.  Diremos que el puntero p apunta a la variable v.
  
-==== Desreferencia ====+===== Desreferencia =====
  
 El operador unario de prefijo '*' permite obtener la variable apuntada por p y se escribe //*p//.  Esto se llama //desreferenciar// p o también se habla del contenido de p: v en este caso.  Si aparece al lado derecho de una asignación significa obtenga el valor de la variable apuntada, por lo tanto el valor de v.  Y si aparece al lado izquierdo, es decir es el destino de una asignación, significa cambie el valor de la variable apuntada, y por lo tanto cambia v.  Estudie el siguiente código: El operador unario de prefijo '*' permite obtener la variable apuntada por p y se escribe //*p//.  Esto se llama //desreferenciar// p o también se habla del contenido de p: v en este caso.  Si aparece al lado derecho de una asignación significa obtenga el valor de la variable apuntada, por lo tanto el valor de v.  Y si aparece al lado izquierdo, es decir es el destino de una asignación, significa cambie el valor de la variable apuntada, y por lo tanto cambia v.  Estudie el siguiente código:
Línea 44: Línea 44:
 {{ :punteros_asignacion.png?nolink&400 |}} {{ :punteros_asignacion.png?nolink&400 |}}
  
-==== Declaración de punteros con valor inicial ====+===== Declaración de punteros con valor inicial =====
  
 Al igual que con cualquier variable, al declarar un puntero es posible darle un valor inicial.  Por ejemplo: Al igual que con cualquier variable, al declarar un puntero es posible darle un valor inicial.  Por ejemplo:
Línea 59: Línea 59:
 Por otra parte, en la asignación //*p= 2//, el asterisco sí es el operador de desreferencia y por lo tanto se está cambiando //a//, no //p//. Por otra parte, en la asignación //*p= 2//, el asterisco sí es el operador de desreferencia y por lo tanto se está cambiando //a//, no //p//.
  
-==== Ejemplo: función que intercambia los valores de 2 variables ====+===== Ejemplo: función que intercambia los valores de 2 variables =====
  
 Al igual que en los métodos de Java, los parámetros de las funciones de C se pasan por valor.  Esto significa que las asignaciones a los parámetros de la función llamada //no cambian// los valores de los argumentos en el llamador.  Por ejemplo consideremos una función que pretende intercambiar los valores de dos variables.  El siguiente código //no funciona//: Al igual que en los métodos de Java, los parámetros de las funciones de C se pasan por valor.  Esto significa que las asignaciones a los parámetros de la función llamada //no cambian// los valores de los argumentos en el llamador.  Por ejemplo consideremos una función que pretende intercambiar los valores de dos variables.  El siguiente código //no funciona//:
Línea 103: Línea 103:
 Escriba la función swap_double que intercambia valores de variables de tipo double. Escriba la función swap_double que intercambia valores de variables de tipo double.
  
-=== Función que intercambia las direcciones de 2 punteros ===+===== Función que intercambia las direcciones de 2 punteros =====
  
 Suponga que ahora tiene este código: Suponga que ahora tiene este código:
Línea 110: Línea 110:
 int main() { int main() {
   int a= 1, b= 2;   int a= 1, b= 2;
-  int *px= &a, *py= &b;+  int *pa= &a, *pb= &b;
   swap_ptr(&pa, &pb);   swap_ptr(&pa, &pb);
 } }
 </code> </code>
  
-Ahora se busca que después de invocar swap_ptr, //px// apunte a //b// y //py// apunte a //a//.  ¿Como habría que definir swap_ptr?  Ahora se necesita que los parámetros de swap_ptr sean punteros a punteros.  Esto se hace empleando 2 asteriscos en la declaración:+Ahora se busca que después de invocar swap_ptr, //pa// apunte a //b// y //pb// apunte a //a//.  ¿Como habría que definir swap_ptr?  Ahora se necesita que los parámetros de swap_ptr sean punteros a punteros.  Esto se hace empleando 2 asteriscos en la declaración:
  
 <code> <code>
Línea 132: Línea 132:
 Por lo tanto al asignar //*p= *q// se está cambiando el valor de px en el llamador (main).  Si quisieramos cambiar el valor de la variable apuntada por lo apuntado por p debemos usar 2 operadores de desreferencia, es decir %%**%%. Por lo tanto al asignar //*p= *q// se está cambiando el valor de px en el llamador (main).  Si quisieramos cambiar el valor de la variable apuntada por lo apuntado por p debemos usar 2 operadores de desreferencia, es decir %%**%%.
  
-=== Como entender la declaración de punteros ===+===== Como entender la declaración de punteros =====
  
 Hay que confesar que la declaración de un puntero simple //int *p// o uno doble //int %%**%%q// no suena natural.  Pero esta notación se entiende más fácilmente de la siguiente forma: Hay que confesar que la declaración de un puntero simple //int *p// o uno doble //int %%**%%q// no suena natural.  Pero esta notación se entiende más fácilmente de la siguiente forma:
Línea 149: Línea 149:
   * Escriba la función swap_ptr_ptr que intercambia 2 variables de tipo //int%%**%%//.   * Escriba la función swap_ptr_ptr que intercambia 2 variables de tipo //int%%**%%//.
  
-==== Comparación de punteros ====+===== Comparación de punteros =====
  
 Se puede determinar si 2 punteros apuntan a la misma variable comparando ambos punteros con los operadores binarios == y !=.  Vea este ejemplo: Se puede determinar si 2 punteros apuntan a la misma variable comparando ambos punteros con los operadores binarios == y !=.  Vea este ejemplo:
Línea 183: Línea 183:
 Aun cuando p!=r, sí se cumple que *p == *r porque en el segundo caso se comparan los valores almacenados en las variables.  Como ambas almacenan 100, entonces son iguales. Aun cuando p!=r, sí se cumple que *p == *r porque en el segundo caso se comparan los valores almacenados en las variables.  Como ambas almacenan 100, entonces son iguales.
  
-==== El puntero nulo ====+===== El puntero nulo =====
  
 Al declarar variables automáticas sin inicialización, su valor es indeterminado.  Nunca considere que es 0.  Es decir un puntero recién declarado apunta a una dirección no determinada.  Si se desreferencia el puntero, se puede obtener una variable ubicada en cualquier parte de la memoria.  Incluso una dirección no asignada al proceso, lo cual se traducirá en una error denominado //segmentation fault//. Al declarar variables automáticas sin inicialización, su valor es indeterminado.  Nunca considere que es 0.  Es decir un puntero recién declarado apunta a una dirección no determinada.  Si se desreferencia el puntero, se puede obtener una variable ubicada en cualquier parte de la memoria.  Incluso una dirección no asignada al proceso, lo cual se traducirá en una error denominado //segmentation fault//.
Línea 207: Línea 207:
  
 No es válido acceder a la dirección NULL en un proceso y por lo tanto si se desreferencia un puntero nulo se produce el error //segmentation fault//. No es válido acceder a la dirección NULL en un proceso y por lo tanto si se desreferencia un puntero nulo se produce el error //segmentation fault//.
-==== Punteros locos ====+===== Punteros locos =====
  
 El tipo del valor retornado por la siguiente función es un puntero.  Esto significa que getvar entrega una dirección como retorno. El tipo del valor retornado por la siguiente función es un puntero.  Esto significa que getvar entrega una dirección como retorno.
Línea 246: Línea 246:
 } }
 </code> </code>
-==== Variables dinámicas ====+===== Variables dinámicas: malloc/free =====
  
 Una variable dinámica se crea explícitamente llamando a la función malloc.  Por lo mismo no tiene identificador, es decir es una variable anónima.  La única forma de llegar a una variable dinámica es a través de un puntero.  El concepto es el mismo de un objeto en Java que se crea con new.  Pero a diferencia de Java, en C todas las variables creadas con malloc se deben destruir explícitamente llamando a la función free.  La función free libera la memoria que ocupaba la variable dinámica destruida y puede ser reutilizada en un futuro malloc.  Si esa variable no se requiere más y no se libera la memoria que ocupa, entonces se transforma en una gotera de memoria (en Inglés //memory leak//). Una variable dinámica se crea explícitamente llamando a la función malloc.  Por lo mismo no tiene identificador, es decir es una variable anónima.  La única forma de llegar a una variable dinámica es a través de un puntero.  El concepto es el mismo de un objeto en Java que se crea con new.  Pero a diferencia de Java, en C todas las variables creadas con malloc se deben destruir explícitamente llamando a la función free.  La función free libera la memoria que ocupaba la variable dinámica destruida y puede ser reutilizada en un futuro malloc.  Si esa variable no se requiere más y no se libera la memoria que ocupa, entonces se transforma en una gotera de memoria (en Inglés //memory leak//).
Línea 263: Línea 263:
   printf("%d\n", *p);   printf("%d\n", *p);
   free(p);   free(p);
 +  return 0;
 } }
 </code> </code>
Línea 274: Línea 275:
 Las variables dinámicas se crean en una zona especial de la memoria de un proceso denominada el //heap//.  Solo malloc y free administran la memoria del heap.  Lamentablemente heap también es el nombre de una estructura de datos que se usa para ordenar arreglos con el método //heapsort//, pero no tienen nada que ver ambos conceptos.  Es solo coincidencia de nombres. Las variables dinámicas se crean en una zona especial de la memoria de un proceso denominada el //heap//.  Solo malloc y free administran la memoria del heap.  Lamentablemente heap también es el nombre de una estructura de datos que se usa para ordenar arreglos con el método //heapsort//, pero no tienen nada que ver ambos conceptos.  Es solo coincidencia de nombres.
  
-=== No hay recolector de basuras ===  +==== No hay recolector de basuras ====
  
 En Java no es necesario liberar la memoria porque posee un recolector de basuras que recicla automáticamente los objetos que ya no son accesibles por el programa.  Pero este recolector tiene un sobrecosto significativo en la ejecución de los programa, sobrecosto que no es deseable para un lenguaje que persigue la eficiencia como C.  Por otra parte, la recolección de basuras impone una disciplina en el manejo de los punteros.  Esto impediría el uso libertino de la memoria en C, como la aritmética de punteros. En Java no es necesario liberar la memoria porque posee un recolector de basuras que recicla automáticamente los objetos que ya no son accesibles por el programa.  Pero este recolector tiene un sobrecosto significativo en la ejecución de los programa, sobrecosto que no es deseable para un lenguaje que persigue la eficiencia como C.  Por otra parte, la recolección de basuras impone una disciplina en el manejo de los punteros.  Esto impediría el uso libertino de la memoria en C, como la aritmética de punteros.
-==== Aritmética de punteros ====+===== Aritmética de punteros =====
  
 La característica más importante de C es su flexibilidad con el manejo de memoria, la que se ve reflejada en la //aritmética de punteros//.  Gracias a esta característica es posible programar un sistema operativo o las funciones malloc y free en C de manera eficiente.  Sin aritmética de punteros habría que recurrir al assembler. La característica más importante de C es su flexibilidad con el manejo de memoria, la que se ve reflejada en la //aritmética de punteros//.  Gracias a esta característica es posible programar un sistema operativo o las funciones malloc y free en C de manera eficiente.  Sin aritmética de punteros habría que recurrir al assembler.
Línea 289: Línea 290:
 </code> </code>
  
-¿De que sirve pedir espacio para 10 enteros consecutivos en la memoria?  Porque a partir del puntero p es posible acceder a todos estos enteros.  La expresión //p+i//, en donde i es un entero entre 0 y 9, apunta al i-ésimo de los enteros.  Por lo tanto la expressión //*(p+i)// representa la i-ésima variable creada.  La siguiente figura ilustra el concepto:+¿De qué sirve pedir espacio para 10 enteros consecutivos en la memoria?  Porque a partir del puntero p es posible acceder a todos estos enteros.  La expresión //p+i//, en donde i es un entero entre 0 y 9, apunta al i-ésimo de los enteros.  Por lo tanto la expressión //*(p+i)// representa la i-ésima variable creada.  La siguiente figura ilustra el concepto:
  
 {{ :punteros_arreglos.png?nolink&600 |}} {{ :punteros_arreglos.png?nolink&600 |}}
Línea 304: Línea 305:
 </code> </code>
  
-=== Azucar sintáctico ===+==== Azucar sintáctico ====
  
 El problema es que escribir *(p+i) es pesado sintácticamente, de modo que en C se define el operador [] como: El problema es que escribir *(p+i) es pesado sintácticamente, de modo que en C se define el operador [] como:
Línea 343: Línea 344:
   ...   ...
   r=p;   r=p;
 +  ...
   free(p);   free(p);
 +  ...
   x= *r; /* r es dangling reference */   x= *r; /* r es dangling reference */
 </code> </code>
  
-Aquí r y p apuntan a la misma dirección de memoria.  Al liberar ese espacio con //free(p)// deja de ser legal acceder a ella por medio de //*p// y //también por medio de *r//.  Aquí el error es trivial de detectar pero en programas más complejos es muy frecuente que accidentalmente se accede a memoria ya liberada muy lejos del código en donde se invocó free y por lo tanto es un error difícil de diagnosticar.  Este error podría conducir a un //segmentation fault// o también conducir a resultados incorrectos.+Aquí r y p apuntan a la misma dirección de memoria.  Al liberar ese espacio con //free(p)// deja de ser legal acceder a ella por medio de //*p// y //también por medio de *r//.  Aquí el error es trivial de detectar pero en programas más complejos es muy frecuente que accidentalmente se accede a memoria ya liberada muy lejos del código en donde se invocó free y por lo tanto es un error difícil de diagnosticar.  Este error podría conducir a un //segmentation fault// o también conducir a resultados incorrectos.  La herramienta comercial //purify// o la gratuita //valgrind// revisan que en la ejecución de un programa no ocurran este tipo de errores.  La desventaja es que el tiempo de ejecución se multiplica por 100.  Además a veces diagnostican errores inexistentes o peor aún, no detectan todos los errores.
  
-=== Restricciones ===+==== Restricciones ====
  
-Solo está permitido sumar o restar un entero a un puntero.  También está permitido restar 2 punteros del mismo tipo.  Pero no tiene sentido multiplicar o dividir un puntero por cualquier valor.  Tampoco tiene sentido sumar 2 punteros.  Por ejemplo si se tienen las siguientes declaraciónes:+Solo está permitido sumar o restar un entero a un puntero.  También está permitido restar 2 punteros del mismo tipo.  Pero no tiene sentido multiplicar o dividir un puntero por cualquier valor.  Tampoco tiene sentido sumar 2 punteros.  Por ejemplo si se tienen las siguientes declaraciones:
  
 <code> <code>
Línea 371: Línea 374:
 En el caso de la resta de punteros, se cumple esta propiedad: %%(p + i) - p ≡ i%% En el caso de la resta de punteros, se cumple esta propiedad: %%(p + i) - p ≡ i%%
  
-=== Arreglos de C vs. arreglos en Java ===+==== Arreglos de C vs. arreglos en Java ====
  
 Dado que en Java los arreglos corresponden a un objeto bien definido con índices que parten en 0 y terminan en el tamaño del arreglo menos 1, Java puede validar cada acceso y arrojar una excepción cuando el índice está fuera del rango permitido.  En cambio en C no se puede determinar donde termina un arreglo y ni siquiera donde comienza porque los índices negativos son válidos y por lo tanto es imposible realizar una validación de los índices.  C nunca podrá reclamar por un índice fuera de rango. Dado que en Java los arreglos corresponden a un objeto bien definido con índices que parten en 0 y terminan en el tamaño del arreglo menos 1, Java puede validar cada acceso y arrojar una excepción cuando el índice está fuera del rango permitido.  En cambio en C no se puede determinar donde termina un arreglo y ni siquiera donde comienza porque los índices negativos son válidos y por lo tanto es imposible realizar una validación de los índices.  C nunca podrá reclamar por un índice fuera de rango.
Línea 379: Línea 382:
 Gracias a la aritmética de punteros es posible programar en C sistemas operativos, malloc/free o el recolector de basuras de Java.  En contrapartida esta aritmética conduce a todo tipo de errores que son muy difíciles de diagnosticar.  Cuando se programa en C es mucho más rentable ser obsesivo en revisar una vez y otra vez el código que se escribe que programar rápido y descansar en que los errores se puede corregir haciendo //debugging//.  La suma del tiempo de codificación más el tiempo de //debugging// será menor en el primer caso que en el segundo. Gracias a la aritmética de punteros es posible programar en C sistemas operativos, malloc/free o el recolector de basuras de Java.  En contrapartida esta aritmética conduce a todo tipo de errores que son muy difíciles de diagnosticar.  Cuando se programa en C es mucho más rentable ser obsesivo en revisar una vez y otra vez el código que se escribe que programar rápido y descansar en que los errores se puede corregir haciendo //debugging//.  La suma del tiempo de codificación más el tiempo de //debugging// será menor en el primer caso que en el segundo.
  
-==== Cast de punteros ====+===== Cast de punteros =====
  
 El significado de un cast de un dato primitivo es distinto del de un cast de un puntero.  Por ejemplo cuando se tiene un dato de tipo double y se le aplica un cast a tipo int, se realiza una conversión en tiempo de ejecución de la representación del dato.  En el bajo nivel la secuencia de bits que representa el número cambia.  Incluso puede cambiar el número porque ''(int)3.14'' es 3. El significado de un cast de un dato primitivo es distinto del de un cast de un puntero.  Por ejemplo cuando se tiene un dato de tipo double y se le aplica un cast a tipo int, se realiza una conversión en tiempo de ejecución de la representación del dato.  En el bajo nivel la secuencia de bits que representa el número cambia.  Incluso puede cambiar el número porque ''(int)3.14'' es 3.
Línea 413: Línea 416:
  
  
-==== Big endian vs. Little endian ====+===== Big endian vs. Little endian =====
  
 ¿Qué valor retorna la siguiente función? ¿Qué valor retorna la siguiente función?
Línea 429: Línea 432:
 {{ :punteros_endianness.png?nolink&400 |}} {{ :punteros_endianness.png?nolink&400 |}}
  
-El valor retornado por esta función depende de una propiedad del hardware.  En los procesadores x86 los punteros apuntan al byte menos significado de un entero.  Esto se denomina una arquitectura //little endian//. Por lo tanto en este tipo de arquitecturas p[0] es 1 y la función de más arriba retorna 1 (o verdadero).  En cambio también existen arquitecturas que se denominan //big endian// en donde los punteros apuntan al byte más significativo de un entero.  La arqutectura Power de IBM es //big endian// así como los //mainframes// que todavía fabrica esta marca.  La arquitectura Sparc de Oracle también es //big endian//.+El valor retornado por esta función depende de una propiedad del hardware.  En los procesadores x86 los punteros apuntan al byte menos significado de un entero.  Esto se denomina una arquitectura //little endian//. Por lo tanto en este tipo de arquitecturas p[0] es 1 y la función de más arriba retorna 1 (o verdadero).  En cambio también existen arquitecturas que se denominan //big endian// en donde los punteros apuntan al byte más significativo de un entero.  La arquitectura Power de IBM es //big endian// así como los //mainframes// que todavía fabrica esta marca.  La arquitectura Sparc de Oracle también es //big endian//.
  
 Los únicos casos en donde esta distinción arquitectural es importante es cuando se graban archivos binarios o se transmiten datos binarios por la red.  Es decir en vez de escribir los enteros en formato ascii en notación decimal, se escriben directamente los 4 bytes del entero.  Si un archivo binario es escrito en una arquitectura little endian pero leído en una arquitectura big endian, los números leídos serán incorrectos. Los únicos casos en donde esta distinción arquitectural es importante es cuando se graban archivos binarios o se transmiten datos binarios por la red.  Es decir en vez de escribir los enteros en formato ascii en notación decimal, se escriben directamente los 4 bytes del entero.  Si un archivo binario es escrito en una arquitectura little endian pero leído en una arquitectura big endian, los números leídos serán incorrectos.
Línea 438: Línea 441:
  
 Programe la función int ''swapEndianness(int x)'' que recibe un entero little endian y entrega uno big endian (o viceversa). Programe la función int ''swapEndianness(int x)'' que recibe un entero little endian y entrega uno big endian (o viceversa).
-==== Resumen ====+===== Resumen =====
  
 La siguiente tabla resume las operaciones con punteros: La siguiente tabla resume las operaciones con punteros:
punteros.1395925935.txt.gz · Última modificación: por lmateu