Está en la página 1de 14

República Bolivariana de Venezuela

Ministerio del Poder Popular para la


Educación Superior Colegio Universitario
Francisco de Miranda

Integrantes:
MORELLA GUZMÁN
HENRY BRACHO

PROFESOR:
Lic. CARLOS ALFONZ
PUNTEROS

DEFINICION DE PUNTEROS

DECLARICION DE PUNTEROS

OPERAC IONES

OPERADORES

PUNTEROS Y ARREGLOS
PUNTEROS

DEFINICION DE PUNTEROS

El tipo de datos más característico del C son los punteros. Un puntero contiene un
valor que es la dirección en memoria de un dato de cierto tipo. Los punteros se
emplean en C para muchas cosas, por ejemplo recorrer vectores, manipular
estructuras creadas dinámicamente, pasar parámetros por referencia a funciones,
etc.

Cuando se declara una variable, se reserva un espacio en la memoria para


almacenar el valor de la variable.
Ese espacio en memoria tiene una dirección.
Un puntero es una dirección dentro de la memoria, o sea, un apuntador a donde
se encuentra una variable.
PUNTEROS

REGLAS BASICAS DE UN PUNTERO

A. Un puntero es una variable como cualquier otra


B. Una variable como puntero contiene una dirección que apunta a otra posición en
memoria
C. En esa posición se almacena los datos a los que apunta el puntero
D. Un puntero apunta a una variable de memoria
PUNTEROS

DECLARACION DE PUNTEROS

DECLARACIÓN DE UN PUNTERO

Cuando declaramos una variable puntero es necesario especificar el tipo


de dato al que va a apuntar o señalar. Para ello se hace preceder a su nombre
con un asterisco (*), mediante el siguiente formato:

E J EM PLO S .

• Punteros a un e
PUNTEROS
EJEMPLOS

•Punteros a un dato: d a to
p

•Punteros a una variable: e s t r u c•Punteros


tu r a a un
p v a r ia b le p c a m1 p o c a m2 p o c a m3 p o

a rra y
•Punteros a un array: •Punt

p cadena

•Punteros a un array bidimensional :


•Punte

p q
PUNTEROS

DECLARACION DE PUNTEROS
/*1*/ struct MyStruct
{/*2*/ int m_aNumber;
/*3*/ float num2;
/*4*/ };
/*5*
/ /*6*/ int * pJ2;
/*7*/ struct MyStruct * pAnItem;

Las primeras 4 líneas definen la estructura, La línea 6 declara una variable que
apuntara a un entero, y la línea 7 declara una variable que apunta a alego de la
estructura MyStruct. Entonces declarar un puntero es algo que apunta a algo de algún
tipo, mas que contener el tipo, el asterisco (*) es ubicado antes del nombre de la
variable.
En las siguientes líneas de código, var1 es un puntero a un entero largo (long)
mientras var2 es un entero largo (long) y no un puntero a un entero largo. En la
segunda línea p3 es declarado como un puntero a un puntero de un entero.
long * var1, var2; int ** p3;
PUNTEROS

DECLARACION MULTIPLE DE PUNTEROS

Si en una misma declaración de variables aparecen varios punteros, hay que escribir
el asterisco a la izquierda de cada uno de ellos:

int *puntero1, var, *puntero2;

Se declaran dos punteros a enteros ( puntero1 y puntero2) y un entero ( var).

DECLARACION DE PUNTERO A PUNTERO


Un puntero puede apuntar a otra variable puntero. Este concepto se utiliza con
mucha frecuencia. Para declarar un puntero a un puntero se hace preceder a la
variable con dos asteriscos ( * * ) .
int **ptr5
PUNTEROS
TIPOS DE PUNTEROS
PUNTEROS (null y void)

Un puntero nulo (null) no apunta a ninguna parte -dato válido- en particular, es decir,
«un puntero nulo no direcciona ningún dato válido en memoria». Para declarar un
puntero nulo se utiliza la macro NULL, definida en los archivos de cabecera STDEF .
H, STDIO. H, STDLIB. H y STRING. H.
#define NULL O
Inicializar una variable puntero a nulo es:
char *p = NULL;

Un puntero (void *; ) declarar de modo que apunte a cualquier tipo de dato, es decir,
no se asigna a un tipo de dato específico y se denomina puntero genérico puede
direccionar cualquier posición en memoria, pero el puntero no está unido a un tipo de
dato específico. De modo similar, los punteros void pueden direccionar una variable
float, una char, o una posición arbitraria o una cadena.

void *ptr; / * declara un puntero void, puntero genérico *


PUNTEROS

OPERADORES DE PUNTEROS

OPERADORES.
t i p o _ v a r v a r ;
t i p o _ v a r * p
p v a r p = & v a r ;

OPERADOR &.

Devuelve la dirección de memo


5 5 i n t
i n t
v
*
a
p
r 1 ,
,
v a r 2 ;
* q ;
p = & v a r 1 ;
p v a r 1 q v a r 2
q = & v a r 2 ;
PUNTEROS

OPERACIONES DE PUNTEROS

OPERACIONES.

ASIGNACIÓN.

puntero  dirección siendo dirección &variable o un


puntero
p= &variable;
p var

p variable1 p variable1
p=q

q variable2 q variable2

Cada puntero definido es necesario inicializarlo asignándole la


dirección correspondiente para que apunte a la variable, dato, etc.
deseado.
PUNTEROS
PUNTEROS Y ARREGLOS
(Arrays)
Los arrays y punteros están fuertemente relacionados en el lenguaje C. Se pueden
direccionar arrays como si fueran punteros y punteros. La posibilidad de almacenar y
acceder a punteros y arrays, implica que se pueden almacenar cadenas de datos en
elementos de arrays. Sin punteros eso no es posible, ya que no existe el tipo de dato
cadena (string) en C. No existen variables de cadena. Únicamente constantes de
cadena.

int a[10];

Define un arreglo de tamaño 10, o sea un bloque de 10 enteros consecutivos que se


acceden a través de a[0], a[1], . . . , a[9].

Un nombre de un array es una constante puntero, no una variable puntero.


PUNTEROS
PRECAUCIONES CON LOS PUNTEROS

Punteros no inicializados
Si se altera el valor al que apunta un puntero no inicializado, se estará modificando cualquier
posición de la memoria.
main()
{
int* puntero;
*puntero = 1200; /* Se machaca una zona cualquiera de la memoria */}

Confusión de tipos
Un puntero a un tipo determinado puede apuntar a una variable de cualquier otro tipo.
Aunque el compilador lo puede advertir, no es un error.
(Afortunadamente, esto no ocurre en C++).
main()
{
int p;
double numero;
int* puntero;
p = № /* incorrecto, pero el compilador no aborta */
*p = 33; /* Un desastre */}
PUNTEROS

Punteros a variables locales fuera de ámbito


Si un puntero apunta a una variable local, cuando la variable desaparezca el
puntero apuntará a una zona de memoria que se estará usando para otros fines.
Los resultados son imprevisibles y a menudo catastróficos.

main()
{
int* puntero;
while (...)
{
int local;
puntero = &local; /* ‘puntero’ apunta a una variable local */
*puntero = 33; /* correcto */ }
/* ahora ‘puntero’ apunta a una zona de memoria inválida */
puntero = 50; /* catástrofe */}