¡Buenas señores! He estado trabajando en un código que me permita trabajar con listas simples a modo de array dinámico y este es el resultado. La idea era que el comportamiento final de la clase fuera fácil e intuitivo, y espero haberlo conseguido 
... Sin embargo la mayor limitación de mi trabajo radica en la forma de agregar los datos, pues sólo se puede introducir a la cabeza o a la cola de la lista, y no de forma aleatoria. A pesar de ello espero que les pueda servir de ayuda en códigos más complicados 
Un ejemplo de su uso[/size]
... Sin embargo la mayor limitación de mi trabajo radica en la forma de agregar los datos, pues sólo se puede introducir a la cabeza o a la cola de la lista, y no de forma aleatoria. A pesar de ello espero que les pueda servir de ayuda en códigos más complicados Código (cpp) [Seleccionar]
// Autor: Namida
// Fecha: 04 enero 2011
/// DIRECTIVAS GENERALES DEL PREPROCESADOR
#define _list_
#ifndef NULL
#define NULL 0
#endif
#define OFF false
#define ON true
///CODIGO
// Declaraciones Previas
template<typename TYPE> class list;
template<typename TYPE> list<TYPE> &operator < (list<TYPE> &L,TYPE X);
template<typename TYPE> list<TYPE> &operator > (list<TYPE> &L,TYPE X);
template<typename TYPE> list<TYPE> &operator ~ (list<TYPE> &L);
// Declaracion
template<typename TYPE> class list
{
private:
/*Definicion del nodo*/
struct node{
TYPE data;
node* next_node;
};
/*Informacion sobre la lista*/
node* first_node;
unsigned list_size;
bool delete_mode;
public:
/*Constructor de clase*/
list();
/*Operadores*/
//Escritura
friend list<TYPE> &operator < <TYPE>(list<TYPE> &L,TYPE X);
friend list<TYPE> &operator > <TYPE>(list<TYPE> &L,TYPE X);
//Lectura
TYPE operator [] (unsigned N);
//Borrado
friend list<TYPE> &operator ~ <TYPE>(list<TYPE> &L);
/*Descriptor*/
unsigned Size();
};
// Metodos
/*Constructor*/
template<typename TYPE> list<TYPE>::list(){
first_node=NULL;
list_size=0;
delete_mode=OFF;
};
/*Operadores*/
//Escritura
template<typename TYPE> list<TYPE> &operator < (list<TYPE> &L,TYPE X){
list<TYPE>::node* new_node=new list<TYPE>::node;
new_node->data=X;
new_node->next_node=NULL;
if (L.first_node!=NULL){
list<TYPE>::node* aux_node=L.first_node;
while (aux_node->next_node!=NULL){
aux_node=aux_node->next_node;
};
aux_node->next_node=new_node;
}else{
L.first_node=new_node;
};
L.list_size+=1;
return L;
};
template<typename TYPE> list<TYPE> &operator > (list<TYPE> &L,TYPE X){
list<TYPE>::node* new_node=new list<TYPE>::node;
new_node->data=X;
new_node->next_node=L.first_node;
L.first_node=new_node;
L.list_size+=1;
return L;
};
//Lectura
template<typename TYPE> TYPE list<TYPE>::operator [] (unsigned N){
try{
if (N<list_size){
switch (delete_mode){
case OFF:
{
node* aux_node=first_node;
for(unsigned i=0;i<N;i++){
aux_node=aux_node->next_node;
};
return aux_node->data;
};
case ON:
{
if (N==0){
node* aux_node=first_node;
first_node=aux_node->next_node;
delete aux_node;
}else{
node* aux_node=first_node;
for(int i=0;i<int(N)-1;i++){
aux_node=aux_node->next_node;
};
node* delete_node=aux_node->next_node;
aux_node->next_node=aux_node->next_node->next_node;
delete delete_node;
};
list_size-=1;
delete_mode=OFF;
throw 0;
};
};
}else{
throw 0;
};
}catch(int code){
TYPE X=TYPE();
return X;
};
};
//Borrado
template<typename TYPE> list<TYPE> &operator ~ (list<TYPE> &L){
L.delete_mode=ON;
return L;
};
/*Descriptor*/
template<typename TYPE> unsigned list<TYPE>::Size(){
return list_size;
};
#undef OFF
#undef ON
Un ejemplo de su uso
Código (cpp) [Seleccionar]
#include"list.h"
int main(int argc,char* argv[]){
//Creacion de una lista tipo int
list<int> L=list<int>();
/* Agregar datos
A la cola*/
L<0<1<2<3<4;
/*A la cabeza*/
L>5>6;
//Estado actual de la lista: 6-5-0-1-2-3-4
//Leer informacion de la lista
L[1]; //Devuelve el numero 5
//Borrado
(~L)[1]; //Elimina el numero 5 de la lista
L.Size(); //Devuelve el tamagno de la lista
return 0;
};
