1. Repaso de Punteros en C++:
A continuación se repasan brevemente los pasos a seguir para usar punteros en C++. En
general, primero se define el tipo correspondiente, después se declaran las variables y se
les pide memoria. Posteriormente se hace el uso que se quiera con ellas y cuando no se
necesitan se borran para reaprovechar el espacio.
Ejemplo
Paso
Tipos Básicos Estructuras
struct Tcomplex
{
double p_r;
double p_i;
};
typedef Tcomplex *TPComplex;
typedef int *TPInt; ó
Definición del Tipo typedef char *TPChar;
typedef struct Tcomplex *TPComplex;
struct Tcomplex
{
double p_r;
double p_i;
};
Declaración de TPInt p_int;
TPComplex p_complex;
varibles TPChar p_char;
p_int = new(int);
p_char = new(char); p_complex = new(Tcomplex);
Petición de
memoria (y if((p_int == NULL) || if(p_complex == NULL)
comprobación de (p_char == NULL)) {
que la ha asignado) { cout << “No hay memoria” << endl;
cout << “No memoria”; }
}
Acceso I: *p_int = 7;
p_complex->p_r = 4.6;
Modifición cin >> *p_char;
Acceso II: cout << *pint;
parte_img = p_complex->p_i;
Consulta un_char = *p_char;
delete(p_int);
Borrado delete(p_char);
delete(p_complex);
Listas Enlazadas en C++:
Repaso breve sobre las listas enlazadas.
Declaración del Tipo:
typedef ... Tdatos; typedef ... Tdatos;
struct Tnodo typedef struct Tnodo *Tlista;
{ struct Tnodo
Tdatos datos; {
Tnodo *sig; Tdatos datos;
}; Tnodo *sig;
typedef Tnodo *Tlista; };

2. Definición de la Variable:
Basura
Tlista primero;
primero
Inicialización de la Lista:
Tlista crear()
{
return NULL; NULL
}
... primero
primero = crear();
Insertar Ordenado:
1. Crear Nodo a insertar
void insertar(Tlista &l, Tdato d)
{
Tlista paux;
paux = new(Tnodo);
if(paux == NULL)
{ d NULL
cout << “ERROR”;
} paux
else
{
paux->dato = d;
paux->sig = NULL;
}
2. Si la lista es vacía introducimos al principio:
NULL
if( l == NULL )
{ l => l
l = paux;
} d NULL d NULL
paux paux
3. Si no es vacía comprobamos si hay que añadir al principio:
e … e …
if( l.dato > d )
{
paux->sig = l;
l => l
l = paux; d NULL d
}
paux paux

3. 4. Insertamos en medio
a b e …
/* Creamos un puntero auxiliar l
para buscar la posición donde
insertar */
pbusca = l; d NULL
pbusca paux
/* Recoremos la lista buscando a b e …
donde insertar */
while( (pbusca->sig != NULL) && l
(pbusca->sig->datos < d))
{ d NULL
pbusca = pbusca->sig;
} pbusca paux
a b e …
/* Una vez encontrada la posición l
insertamos el nuevo nodo */
paux->sig = pbusca->sig;
pbusca->sig = paux; d
pbusca paux
Borrar:
Borrar es similar a la insertar. Primero se comprueba si es vacía, en tal caso no
hacemos nada. Si no está vacía buscamos el elemento que queramos borrar, y una vez
localizado, lo sacamos de la lista y liberamos la memoria que tenía asignada-
1. Borrado del primer elemento
if(l->dato == d)
{
ptr = l;
l = l->sig;
delete(ptr);
}
d e ... => d e ...
l l
ptr ptr

4. 2. Borrado de un elemento intermedio
/* Creamos dos punteros a b d e …
auxiliares uno que examine la
posición actual y otro que l
indique la posición anterior
*/
pact = l->sig;
pant = l; pant pact
/* Recoremos la lista
buscando el nodo a borrar*/ a b d e …
while((pact != NULL) &&
l
(pact->dato != d))
{
pant = pact;
pact = pact->sig;
} pant pact
/* Una vez encontrada la
posición borramos el nodo */ a b d e …
if(pact != NULL)
{
l
pant->sig = pact->sig;
delete(pact);
}
pant pact