Wiki CC3301

Herramientas de usuario

Herramientas del sitio

Estás aquí: start » punteros
Traza:
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 [2012/08/03 21:54] – [Aritmética 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 199: Línea 199:
 } }
 ... más código ... ... más código ...
-if (p == NULL) {+if (p != NULL) {
   *p= 50;   *p= 50;
 } }
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 231: Línea 230:
   * La memoria que ocupó alguna vez x sí fue reasignada y se le dió un nuevo valor distinto de 1.  Al desreferenciar p se obtiene un valor incorrecto.   * La memoria que ocupó alguna vez x sí fue reasignada y se le dió un nuevo valor distinto de 1.  Al desreferenciar p se obtiene un valor incorrecto.
  
-==== Variables dinámicas ====+**Ejercicio** 
 +¿Qué despliega el siguiente programa? 
 + 
 +<code> 
 +#include <stdio.h> 
 + 
 +int *getvar(int x) { 
 +  return &x; /* Incorrecto: no haga esto! */ 
 +} 
 + 
 +int main() { 
 +  int *p= getvar(1); 
 +  int *q= getvar(2); 
 +  printf("%d %d\n", *p, *q); 
 +} 
 +</code> 
 +===== 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 239: Línea 254:
 <code> <code>
 int *getvar() { int *getvar() {
-  int *q= (int*)malloc(sizeof(int));+  int *q= malloc(sizeof(int));
   *q= 1;   *q= 1;
   return q;   return q;
Línea 248: Línea 263:
   printf("%d\n", *p);   printf("%d\n", *p);
   free(p);   free(p);
 +  return 0;
 } }
 </code> </code>
  
-Al invocar malloc se debe especificar el tamaño de la memoria requerida.  Usualmente se usa el operador de prefijo sizeof para calcular el espacio requerido por un tipo determinado, en este caso int.  El cast (int*) se necesita porque si no se coloca, el compilador reclama que el tipo retornado por malloc no es compatible con el tipo de q.  Este cast no afecta en modo alguno el valor de la variable recién creada.  Tampoco afecta la dirección asignada a q.  Solo es una promesa hecha al compilador que la dirección corresponde a la de una variable entera.+Al invocar malloc se debe especificar el tamaño de la memoria requerida.  Usualmente se usa el operador de prefijo sizeof para calcular el espacio requerido por un tipo determinado, en este caso int.
  
 Note que al retornar getvar, se destruyen todas sus variables locales (automáticas).  Esto incluye el puntero q.  Pero la variable creada con malloc **no es destruida**.  Como su dirección es retornada por getvar y almacenada en el puntero p de main, es legal desreferenciar p y obtener así el valor 1.  La siguiente figura muestra las variables que intervienen: Note que al retornar getvar, se destruyen todas sus variables locales (automáticas).  Esto incluye el puntero q.  Pero la variable creada con malloc **no es destruida**.  Como su dirección es retornada por getvar y almacenada en el puntero p de main, es legal desreferenciar p y obtener así el valor 1.  La siguiente figura muestra las variables que intervienen:
Línea 259: 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 268: Línea 284:
 Ningún otro lenguaje de programación ampliamente usado ofrece aritmética de punteros.  Pero esta característica es un arma de doble filo en C, porque también conduce a errores de programación que son difíciles de diagnosticar, incluso para expertos. Ningún otro lenguaje de programación ampliamente usado ofrece aritmética de punteros.  Pero esta característica es un arma de doble filo en C, porque también conduce a errores de programación que son difíciles de diagnosticar, incluso para expertos.
  
-Para enteder como funciona la aritmética de punteros consideremos la siguiente instrucción:+Para entender como funciona la aritmética de punteros consideremos la siguiente instrucción:
  
 <code> <code>
-int *p= (int*)malloc(10*sizeof(int));+int *p= malloc(10*sizeof(int));
 </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 289: 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 298: Línea 314:
  
 <code> <code>
-  int *p= (int*)malloc(10*sizeof(int));+  int *p= malloc(10*sizeof(int));
   int s= 0;   int s= 0;
   int i;   int i;
Línea 312: Línea 328:
  
 <code> <code>
-  int *p= (int*)malloc(10*sizeof(int));+  int *p= malloc(10*sizeof(int));
   int s= 0;   int s= 0;
   int i;   int i;
Línea 325: Línea 341:
 <code> <code>
   int *p, *r, x; /* x no es puntero */   int *p, *r, x; /* x no es puntero */
-  p= (int*)malloc(...);+  p= malloc(...);
   ...   ...
   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.
  
-=== Ejercicio ===+==== Restricciones ====
  
-El siguiente programa es absolutamente legal en C.  ¿Qué hace? +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> +
-  int *p= ( (int*)malloc(10*sizeof(int)) ) + 5; /* Ojo con el + 5 al final */ +
-  int i; +
-  for (i= -5; i<5; i++) +
-    p[i]= 0; +
-</code> +
-   +
-Por supuesto, acá no se está fomentando este estilo de programación, que es //detestable//, si no que sirve para ilustrar que el uso de índices negativos es perfectamente legal y su semántica está bien definida. +
- +
-=== 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:+
  
 <code> <code>
Línea 369: 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 377: 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 391: Línea 396:
 </code> </code>
  
-Este código es perfectamente legal en C aunque es difícil predecir cuáles serán los valores de i y j.  Ciertamente no es algo ni remotamente parecido a 3 o 3.14159, pero mientras que el compilador considera que //*p// es un variable real (de tamaño 8), la expresión //*q// corresponde a una variable entera de 4 bytes.  Incluso es legal acceder a los siguientes 4 bytes utilizando q como un arreglo: //q[1]//.  La siguiente figura grafica la situación:+Este código es perfectamente legal en C aunque es difícil predecir cuáles serán los valores de i y j.  Ciertamente no es algo ni remotamente parecido a 3 o 3.14159, pero mientras que el compilador considera que //*p// es una variable real (de tamaño 8), la expresión //*q// corresponde a una variable entera de 4 bytes.  Incluso es legal acceder a los siguientes 4 bytes utilizando q como un arreglo: //q[1]//.  La siguiente figura grafica la situación:
  
 {{ :punteros_cast.png?nolink&400 |}} {{ :punteros_cast.png?nolink&400 |}}
  
-Es importante destacar que en la mayoría de los casos asignar un puntero a otro puntero de distinto tipo conduce a un error de programación.  Por eso el compilador reclama si no se coloca el cast //int*// en el código de más arriba porque en la mayoría de los caso no era la intención del programador que tuviesen tipos distintos.  Es una forma de prevenir al programador de que está haciendo algo peligroso.  Cuando el programador coloca el cast, está prometiendo al compilador que //sabe lo que está haciendo//.+Es importante destacar que en la mayoría de los casos asignar un puntero a otro puntero de distinto tipo conduce a un error de programación.  Por eso el compilador reclama si no se coloca el cast //int*// en el código de más arriba, porque en la mayoría de los caso no era la intención del programador que tuviesen tipos distintos.  Es una forma de prevenir al programador de que está haciendo algo peligroso.  Cuando el programador coloca el cast, está prometiendo al compilador que //sabe lo que está haciendo//.
  
-==== Big endian vs. Little endian ====+=== Ejercicio === 
 + 
 +El siguiente programa es absolutamente legal en C.  ¿Qué hace? 
 + 
 +<code> 
 +  int *p= ( (int*)malloc(10*sizeof(int)) ) + 5; /* Ojo con el + 5 al final */ 
 +  int i; 
 +  for (i= -5; i<5; i++) 
 +    p[i]= 0; 
 +</code> 
 +   
 +Por supuesto, acá no se está fomentando este estilo de programación, que es //detestable//, si no que sirve para ilustrar que el uso de índices negativos es perfectamente legal y su semántica está bien definida. 
 + 
 + 
 +===== Big endian vs. Little endian =====
  
 ¿Qué valor retorna la siguiente función? ¿Qué valor retorna la siguiente función?
Línea 413: 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.
-==== Resumen ====+ 
 +Por lo tanto la función de más arriba sí es útil para determinar en qué formato enviar valores por la red. 
 + 
 +=== Ejercicio === 
 + 
 +Programe la función int ''swapEndianness(int x)'' que recibe un entero little endian y entrega uno big endian (o viceversa). 
 +===== Resumen =====
  
 La siguiente tabla resume las operaciones con punteros: La siguiente tabla resume las operaciones con punteros:
Línea 428: Línea 453:
 |puntero nulo | ''p==NULL'' | Verdadero si p apunta a la dirección 0 de memoria | |puntero nulo | ''p==NULL'' | Verdadero si p apunta a la dirección 0 de memoria |
 |aritmética de punteros | ''p+i'' | Entrega la dirección de la i-ésima variable consecutiva en memoria con *p | |aritmética de punteros | ''p+i'' | Entrega la dirección de la i-ésima variable consecutiva en memoria con *p |
- 
punteros.1344030870.txt.gz · Última modificación: 2012/08/03 21:54 por lmateu