Omitir navegación.
Inicio
odiolasllaves.com.ar
Inicio » Carrera AUS » 2.11.1 Taller II » Taller con Guido Macchi

090414 Clase 14 de abril

Imagen de SebaMinguez
Enviado por SebaMinguez el Jue, 04/16/2009 - 02:02.

Algunos ejemplos de punteros, constantes matematicas predefinidas y arreglos. 

#include <stdio h>
#include <math h>
 
double a [] = { M_PI, M_E, M_E + M_PI};
int main()
{
	double *p = &amp; a[];
	printf("%p: %f \n", p, *p);
	printf("%p: %f \n", p+1, *(p+1));
	printf("%p: %f \n", p+2, *(p+2));
	return ;
}
El programa anterior utiliza el puntero para acceder al arreglo, cargando la primera posicion y accediendo a la siguiente (+1) y a la siguiente (+2), etc. Por lo tanto devuelve: 
sad@snarf:~/Escritorio/AUS/Segundo/Taller C$ gcc PunterosTest.c 
sad@snarf:~/Escritorio/AUS/Segundo/Taller C$ ./a.out 
0x804a018: 3.141593 
0x804a020: 2.718282 
0x804a028: 5.859874
Al similar puede hacerse con un for: 
#include <stdio h>
int a[] = { , 1 ,2 ,3};
int main ()
{
	int i, *p=&amp; a[];
	for (i=, i&lt; sizeof(a)/sizeof(a[]; i++))
		printf("%d \n", *(p+i));
	for (i=, i &lt; 4; i++)
		printf("%d \n", a[i]);
	for (i=, i &lt; 4; i++)
		printf("%d \n", p[i]); /* puntero como arreglo */
	for (i=, i &lt; 4; i++)
		printf("%d \n", *(a+i)); /* arreglo como puntero */
	return 
}

Un puntero como arreglo da lo mismo que un arreglo como puntero. Esto es porque, en C, un arreglo (de una dimension) ES un puntero. O casi...

Modificadores const y volatile

const convierte una variable en read-only Ej: 

int i=1;
const int j=2;
i=j; /* esto es correcto */
j=i; /* Esto es un error */
Con punteros hay mas posibilidades. Puedo cambiar el valor del puntero como lo apuntado por el puntero. 
int *p=&i;
p=&j; 
*p=1;
Siendo un puntero clasico y todo es correcto. Ahora, veamos al utilizar const: 
const int *p=&amp;i
p=&j; /*correcto */
*p=1; /* ahora es un error*/
int *const p=&i;
p=&j; /* error */
*p=1; /* Correcto */
const int *const p=&i;
p=&j; /* error */
*p=1; /* error */
Un arreglo es un puntero constante, que apunta a un espacio predefinido. volatile indica que una variable es muy variable. Es decir que varia sin que el proceso la modifique, porque puede ser modificada por un proceso externo. 
int flag == ;
while (flag == )
	; /*no hacer nada */
Compilando con la opcion de mucha optimizacion (-O6) el compilador entenderia que flag no cambia y eliminaria la comparación Para esto se indica que flag es volatile 
volatile int flag == ;
while (flag == )
	; /*no hacer nada */

Argumentos de main

Recibe tres argumentos:

  • un int que representa el numero de argumentos
  • un char** que contiene los argumentos en si
  • un char** que contiene el entorno de ejecucion 

#include <stdio>
 
int main (int argc, char **argv, char **env)
{
	int i;
	for (i=, i &lt; argc; i++)
		printf("argv[%d]=%s\n",i,argv[i]);
	getchar();
 
	for (i=, env[i]!=NULL; i++)
		printf("%s \n", env[i]);
	return ;
}

Memoria Dinamica

Es una memoria extra alocada durante la ejecucion se pide con: 

void *malloc (unsigned cuantosCharts)
Nota: void * es un puntero "universal" que puede asignarse sin cast Se libera con 
int free(punteroObtenidoConMalloc)

Registros de datos y Lemuel Gulliver

Llilliput y Blufescu se peliaban por como se cascaba un huevo. Los primeros eran los Litle Endian y los segundos los Big Endian. Esto se utilizó para indicar como se almacenan los datos en memoria. Direccion -> ..| 12 | 34 | 56 | 78 | .. Esto es un procesador Big Endian ..| 78 | 56 | 34 | 12 | .. Esto es un procesador Litle Endian ..| 34 | 12 | 78 | 56 | .. PDP/11 un viejo en vias de extincion Un programita para averiguar que tipo es nuestro procesador. 

#include <stdio h>
int main()
{
	int i=0x12345678;
	char *p=(char*)&i; // esto es para evitar el warnig por distintos tipos
 
	printf("%s \n", p[] == 0x12 &amp;&amp; p[3] == 0x78 ? "big" : "litle");
	return 
}

Trackback URL for "090414 Clase 14 de abril"

http://www.odiolasllaves.com.ar/trackback/95
»