Beruflich Dokumente
Kultur Dokumente
1 .- APUNTADORES
Los apuntadores permiten simular llamadas por referencia, crear, y
manipular estructura de datos.
Un puntero es una variable que guarda localizaciones de memoria.
Un puntero guarda las direccin de las variables.
Los punteros son variables que pueden contener la direccin de otra
variable, y estn almacenados en memoria teniendo su propia direccin.
Un puntero e s una direccin de memoria.
2.- DECLARACIN DE PUNTEROS.
tipo *nombrepuntero
numbrepuntero o el nombre del apuntador.
Ej. 2.1
int *p; Es un puntero de nombre p a variable entero.
p apunta a un objeto de tipo entero
p es un apuntador a un entero.
1
Ej. 2.2
int *p, q; // declara a p como apuntador que podr tener la direccin de
cualquier variable de tipo entero y q se declara como una
variable de tipo entero,
Ej. 2.3
int *ptrsuma; //ptrsuma es un puntero a valores enteros
Una vez declarada una variable de apuntador es necesario conocer:
& operador de direccin(referencia)
* operador de in direccin (desreferencia)
3.- & OPERADOR DE DIRECCIN O DE REFERENCIA
& Es un operador unuario que asigna la direccin de su operando.
p=&q
Ej. 3.3
# include <stdio.h>
# include <stdlib.h>
main()
{
int i=5,j;
int *ptr;
ptr=&i;
ptr=&j;
//variable i
//asigna la direccion de memoria de la variable j al
//apuntador ptr
j=-4;
printf(" j=%d\n",j); // valor de la variable j
printf(" ptr=&j;\n ptr=%d\n ",ptr);// direccin de memoria de la variable j
printf("*ptr=%d\n",*ptr);// regresa el valor que tiene apuntando a la
variable j
system("pause");
}
RESULTADOS:
i=5
ptr=&i;
ptr=2293620
*ptr=5
i=10
ptr=2293620
*ptr=10
j=-4
ptr=&j;
ptr=2293616
*ptr=-4
Presione una tecla para continuar . . .
//prototipo de funcion
main ( )
// archivo cabecera (header)
{
printf("cuadrado de un numero ");
printf("los argumentos a una funcion");
printf(" pasan por valor");
int num=2;
printf("numero %d\n",num);
num=cuadrado(num);
//llamado de la funcion donde num es el
// argumento de entrada y regresa la funcion
// regreso por valor
//
printf("cuadrado %d\n",num);
system("pause");
return 0;
}
int cuadrado(int y)
//definicin de funcion
{
// y es una copia del argumento de la funcion
int c;
c=y*y;
return c;
//devuelve el valor cuadrado de y como un int
//o retun y*y;
}
// pasa la variable y a la funcion cuadrado mediante una llamada por valor
//argumento de entrada por valor
// la funcion cuadrado eleva al cubo su argumento y regresa el valor de c
// a main mediante la instruccion return.
//prototipo de funcion
main ( )
// archivo cabecera (header)
{
printf("cuadrado de un numero\n ");
printf("los argumentos a una funcion\n");
printf(" pasan por referencia\n");
int num=2;
printf("numero %d\n",num);
cuadrado(&num);
//llamado de la funcion donde &num
// da la direccion a la funcion
printf("cuadrado %d\n",num);
system("pause");
return 0;
}
void cuadrado(int *pnum)
//definicin de funcion
{
//
*pnum=*pnum**pnum;
}
Ej. cambios con funciones.
//cambio
# include <stdio.h>
# include <stdlib.h>
void cambiar (int, int);
main( )
{
printf("cambiar\n");
int a=1, b=2;
printf("en principal\n");
printf("a=%d y b=%d\n", a,b);
cambiar (a,b);
printf("regresando de la funcion en principal\n");
printf("a=%d y b=%d\n", a,b);
system ("pause");
return 0;
}
6
//cambio 1
# include <stdio.h>
# include <stdlib.h>
void cambiar (int, int);
main( )
{
int a=1, b=2;
printf ("cambio1/n");
printf("a=%d y b=%d\n", a,b);
printf ("en main\n");
cambiar (a,b);
printf( "regresando de la funcion\n");
printf("a=%d y b=%d\n", a,b);
system ("pause");
return 0;
}
void cambiar (int a, int b)
{
int c;
c=a;
a=b;
7
b=c;
printf( "dentro de la funcion\n");
printf("a=%d y b=%d\n",a,b);
}
//cambio 2
//cambio 2
# include <stdio.h>
# include <stdlib.h>
void cambiar (int*, int*);
main( )
{
int a=1, b=2;
printf("imprimiento valores asignados en main\n");
printf("a=%d y b=%d\n", a,b);// son los valores asignados
cambiar (&a,&b);
//se pasa la direccin de a y b a la funcin
// cambiar.
// la funcin llamada modifica a la variable
// que llama
printf("Regresando a Main\n");
printf("a=%d y b=%d\n", a,b);
system ("pause");
return 0;
}
void cambiar (int *pa, int *pb) // toma como apuntadores a pa y pb ambos de
// de tipo entero.
{
printf("Dentro de la funcin cambiar\n");
printf("pa=%d y pb=%d\n",pa,pb);
int c;
c=*pa;
*pa=*pb;
// se asigna el resultado a *pa
*pb=c;
// se asigna el resultado a *pb
printf("pa=%d y pb=%d\n",pa,pb);
printf("*pa=%d y *pb=%d\n",*pa,*pb);
Ejemplo
#include <stdio.h>
#include <stdlib.h>
main()
{
int j;
int A[10];
printf("impresion de datos del arreglo\n");
for(j=0;j<3;j++)
{*(A+j)=j*j;
printf("A[%d]=, %d\n",j,A[j]);
}
for(j=0;j<3;j++)
{A[j]=j*j;
printf("(A+%d)=,%d\n",j,*(A+j));
}
system("pause");
}
EJEMPLO
#include <stdio.h>
#include <stdlib.h>
main()
{
int i,j;
int A[3]={1,2,3};
A[10]=0;
printf("impresion de datos del arreglo\n");
for(j=0;j<3;j++)
{printf("A[%d]=, %d\n",j,A[j]);}
10
system("pause");
int *pa=A;// establece que el apuntador pa de tipo entero apunte al arreglo
b;
printf("impresion de datos del apuntador pa notacion Subindices de
arreglo\n");
for(j=0;j<3;j++)
{printf(" pa[%d]=, %d\n",j,pa[j]);}
system("pause");
printf("impresin de datos del arreglo A \n");
printf(" mediante notacion apuntador desplazamiento\n" );
printf(" donde el apuntador es el nombre del arreglo\n" );
for(j=0;j<3;j++)
{printf(" *(A+%d)=, %d\n",j,*(A+j));}
// donde j en este caso es un desplazamiento
system("pause");
printf("impresion de datos de los valores del apuntador pa \n");
printf(" mediante notacin apuntador desplazamiento\n" );
for(j=0;j<3;j++)
{printf(" *(pa+%d)=, %d\n",j,*(pa+j));}
// donde j en este caso es un desplazamiento
system("pause");
}
11
Tarea inverstigar las siguientes instrucciones: sizeof y malloc sobre todo orientado a
apuntadores.
Sizeof, malloc, free
Es un operador que regresa el tamao en bytes de datos o de un arreglo
http://sopa.dis.ulpgc.es/so/cpp/intro_c/introc75.htm
Tamao de memoria de los tipos de datos
#include<iostream>
sizeof (char) 1 byte
sizeof (short) 2 bytes
sizeof(int) 4 bytes
sizeof(float)
sizeof(double)
sizeof(short)
malloc usos (sobre todo a punteros)
sirve para que una variable sea dinmica
12
Funcin free
Cuando una zona de memoria reservada con malloc ya no se necesita, puede
ser liberada mediante la funcin free.
#include <stdlib.h>
int* ptr; /* puntero a enteros */
int* ptr2; /* otro puntero */
...
/* reserva hueco para 300 enteros */
ptr = (int*)malloc ( 300*sizeof(int) );
...
ptr[33] = 15;
/* trabaja con el rea de
memoria */
rellena_de_ceros (10,ptr);
ptr2 = ptr + 15;
puntero */
/* otro ejemplo */
/* asignacin a otro
14
/* declares malloc() */
fp = (float *)malloc(sizeof(float));
In the last example, the array ar is an array of 100 ints; after the call to malloc
(assuming that it was successful), ip will point to a region of store that can also
be treated as an array of 100 ints.
The fundamental unit of storage in C is the char, and by definition
sizeof(char)
is equal to 1, so you could allocate space for an array of ten chars with
malloc(10)
while to allocate room for an array of ten ints, you would have to use
malloc(sizeof(int[10]))
If malloc can't find enough free space to satisfy a request it returns a null
pointer to indicate failure. For historical reasons, the stdio.h header file
contains a defined constant called NULL which is traditionally used to check the
return value from malloc and some other library functions. An explicit 0 or (void
*)0 could equally well be used.
15