Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

Punteros en C

Punteros en lenguaje C - Punteros Dobles y listas enlazadas. Pila implementada con listas y punteros dobles
by

Gabriel Chaldu

on 26 September 2016

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Punteros en C

Puntero: Introducción
Punteros, Punteros dobles en C con listas Enlazadas
Este operador
aplicado a una variable

retorna la dirección de memoria
de la misma.



sintaxis:

&id_variable



Operador &
Se denomina
variable
de
tipo puntero
a aquella que
almacena como dato la dirección de memoria de otra variable.
Punteros: Definición
Otro Ejemplo:
Un ejemplo con Funciones
sintaxis de puntero DOBLE:

tipo_dato
**
id_variable;
Puntero a Puntero
Un PaP (puntero a puntero) puede modificar la dirección de memoria que contiene otro puntero.
"La ventaja" de usar puntero a puntero
int main(){
int
a
=10;
int
b
=20;
int
* p
=
&a
;
int
* *pp
=
&p
;

*pp
=
&b
;

// aqui le indicamos al puntero p (por medio del puntero doble) que ahora apunte a la variable b
}
Ejemplo
Toda variable:
IMPORTANTE
sintaxis:


Ejemplo
int main(){
int
a
=10;
int
*p
=
&a
;
int
**pp
=
&p
;
}
Variable cuyos posibles valores son direcciones de memoria de otras variables puntero.
"Las funciones que devuelven varios valores usan pasaje por referencia para “devolver” los resultados que no pueden ser devueltos con un return:
TDA Pila (implementado con listas)
Ejemplo
void
inicPila
(nodo
** pila
)
{
(
*pila
)=
inicLista()
;
}
nodo *
inicLista
()
{
return NULL;
}
void apilar (nodo ** pila, int dato)
{
nodo * aux=
crearNodo
(dato);
(*pila)=
agregarPpio
((*pila),aux);
}
nodo * crearNodo(int dato)
{
nodo * aux = (nodo*)malloc(sizeof(nodo));
aux->dato = dato;
aux->siguiente = NULL;
return aux;
}
nodo * agregarPpio(nodo * lista, nodo * nuevoNodo)
{

if(lista == NULL)
{
lista = nuevoNodo;
}
else

{
nuevoNodo->siguiente = lista;
lista = nuevoNodo;
}
return lista;
}
void mostrar(nodo ** pila)
{

nodo * seg = (*pila);
printf("\nTope ");
while(seg!=NULL)
{
printf ("Dato: %d\n",seg->dato);
seg=seg->siguiente;
}
printf("Base\n");
}

Le asigno la referencia
int
main
()
{
nodo * pilita;

inicPila(&
pilita);


apilar(&
pilita, 10);

apilar(&
pilita, 20);

apilar(&
pilita, 30);


mostrar(&
pilita);
}
Ejemplo
void punteroDoble(
nodo * *
p_lista){
nodo *
primero;
if( (
*p_lista
) != NULL )
{
primero =
*p_lista
;
*p_lista
= (
*p_lista
)->siguiente;
free(primero);
}
}

int main(){
nodo *
listaMain;
listaMain = inicLista();
// cargamos la lista...
punteroDoble(
&
listaMain);
...
}
Memoria de la pc...
TDA Pila
(implementado con listas)
Prototipado de funciones básicas:
void inicPila (nodo ** pila)
int pilavacia (nodo ** pila)
int tope (nodo ** pila)
int desapilar (nodo ** pila)
void apilar (nodo ** pila, int dato)
void leer (nodo ** pila)
void mostrar (nodo ** pila)
TDA Pila
(implementado con listas)
Prof. Gabriel Chaldu
Prof. Gustavo Sonvico

¿Para que utilizamos variables?
MANIPULAR DIRECCIONES DE MEMORIA.
ALMACENAR DATOS.
Tiene una dirección de memoria,
Podemos conocerla (&).
No podemos asignarlo en forma arbitraria.
tipo_dato
*
id_variable;
puntero doble
Asigno la Dir Mem.
de (p)
Full transcript