Ecco finalmente la mia libreria (qui vi posto un sorgente con tutto già implementato, però si può senza troppa fatica crearsi una libreria) per la gestione di semplici liste dinamiche in C.
Il programma allegato include anche degli esempi di utilizzo delle funzioni per le liste dinamiche, così che possiate capire come si usa.
Successivamente inserirò anche le funzione per il salvataggio/lettura di una lista su file, così da poter esportare le liste dinamiche.
Scriverò anche un piccolo PDF che ne spiega il funzionamento.
Questa è una BETA, potreste trovare dei memory leak, degli sprechi o dei bug, se notate qualcosa di sbagliato e/o da migliorare ditemelo pure.
Ovviamente è testato e funziona su Linux compilato con GCC, ecco il programma:
EDIT: Ovviamente vi consente di gestire più liste contemporaneamente, essendo la lista una struttura. Questa libreria può essere utile per esempio in un programma server, che dovendo gestire più di una connessione, ha bisogno di una lista dinamica in cui salvare le sessioni e le connessioni aperte con i relativi indirizzi IP.
Aggiungo anche che la lista salva i dati in formato char (o byte), quindi per poterci salvare numeri interi (e quindi trarne il vantaggio di poterci fare operazioni aritmetiche) sarà necessario prelevare i caratteri ASCII corrispondenti e usare una funzione atoi(), per poi ri-salvare i dati in lista usando la funzione itoa();
http://pastebin.com/f7ef740c3/*
* list.c - ShellCoder_
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*/
#include <stdio.h>
#include <string.h>
#define FIRST 0
typedef struct {
char** items;
int counter;
} LIST;
void Menu(void);
void Init_List(LIST* list);
int Push_to_list(LIST* list, char* item);
char* Read_to_list(LIST* list, int pos);
int Item_Exists(LIST* list, char* item);
char* Pop_to_list(LIST* list, int pos);
void Destroy_List(LIST* list);
LIST prova;
int main(void)
{
Init_List(&prova);
int scelta;
char* elemento = (char*)malloc(99*sizeof(char));
int posizione;
while(1==1)
{
Menu();
scanf("%d",&scelta);
if(scelta==1)
{
printf("Elemento da aggiungere: ");
scanf("%s",elemento);
printf("\nNumero totale di elementi: %d\n\n",Push_to_list(&prova,elemento));
}
else if(scelta==2)
{
printf("Posizione elemento da leggere: ");
scanf("%d",&posizione);
printf("\nElemento letto: %s\n\n",Read_to_list(&prova,posizione));
}
else if(scelta==3)
{
printf("Inserire stringa di ricerca: ");
scanf("%s",elemento);
int pos = Item_Exists(&prova,elemento);
if(pos == -1)
{
printf("\nL'elemento non esiste.\n\n");
}
else
{
printf("\nL'elemento esiste alla posizione %d\n\n",pos);
}
}
else if(scelta==4)
{
printf("Cancellare (e)elemento o (p)posizione?\n");
char a;
scanf("\n%c",&a);
if((a=='e')||(a=='p'))
{
if(a=='e')
{
printf("Inserire elemento da cancellare: ");
scanf("%s",elemento);
int pos = Item_Exists(&prova,elemento);
if(pos!= -1)
{
Pop_to_list(&prova,pos);
printf("\nL'elemento %s è stato cancellato dalla posizione %d\n\n",elemento,pos);
}
else
{
printf("\nL'elemento non esiste!\n\n");
}
}
else
{
printf("Inserire la posizione su cui cancellare: ");
scanf("%d",&posizione);
char* success = Pop_to_list(&prova,posizione);
if(success == NULL)
{
printf("\nLa posizione indicata e' inesistente o non valida!\n\n");
}
else
{
printf("\nL'elemento %s è stato cancellato dalla posizione %d\n\n",success,posizione);
}
}
}
else
{
printf("\nScelta sbagliata. scegli 'p' o 'e'.\n\n");
}
}
else if(scelta==5)
{
printf("Lettura elementi in corso...\n");
if(prova.counter == -1)
{
printf("\nNessun elemento esistente.\n\n");
}
else
{
int i = 0;
printf("\n");
while(i<=prova.counter)
{
printf("%s ",Read_to_list(&prova,FIRST+i));
i++;
}
printf("\n\n");
}
}
else if(scelta==6)
{
printf("\nGli elementi salvati sono: %d\n\n",prova.counter);
}
else if(scelta==7)
{
char scelta;
printf("Sei sicuro di voler deallocare e cancellare la lista? [y/n]\n");
scanf("\n%c",&scelta);
if(scelta=='y')
{
Destroy_List(&prova);
printf("Lista deallocata e cancellata con successo. Uscita in corso tra 5 secondi:");
sleep(1);
sleep(4);
exit(0);
}
}
else if(scelta==8)
{
exit(0);
}
else
{
printf("\nScelta non valida\n\n");
}
}
return 0;
}
void Menu(void)
{
printf("1) Aggiungere elemento\n");
printf("2) Leggere elemento\n");
printf("3) Verificare l'esistenza di un elemento\n");
printf("4) Cancellare un elemento\n");
printf("5) Leggere tutti gli elementi in ordine\n");
printf("6) Contare gli elementi\n");
printf("7) Dealloca la lista\n");
printf("8) Esci\n");
}
/* -------- DA QUI INIZIA IL CODICE DELLE FUNZIONI PER LA GESTIONE DELLE LISTE ---------- */
void Init_List(LIST* list){ /* Funzionante */
list->items = (char**)malloc(1*sizeof(char*));
list->counter = -1;
}
int Push_to_list(LIST* list, char* item){ /* Funzionante */
list->counter++;
list->items[list->counter] = (char*) malloc((strlen(item)+1)*sizeof(char));
int a = 0;
while(*item!='\0')
{
list->items[list->counter][a]=*item;
item++;
a++;
}
list->items[list->counter][a] = '\0';
list->items = realloc(list->items, (list->counter+2) * sizeof(char*));
return list->counter;
}
char* Read_to_list(LIST* list, int pos) /* Funzionante */
{
if((pos < 0) || (pos > list->counter))
{
return NULL;
}
else
{
return list->items[pos];
}
}
int Item_Exists(LIST* list, char* item) /* Funzionante */
{
int i = 0;
while(i<=list->counter)
{
if(strcmp(list->items[i],item)==0)
{
break;
}
else
{
i++;
}
}
if(i > list->counter)
{
return -1;
}
else
{
return i;
}
}
char* Pop_to_list(LIST* list, int pos) /* Funzionante */
{
if((pos < 0) || (pos > list->counter))
{
return NULL;
}
else
{
char* ptr = (char*)malloc(strlen(list->items[pos])+1*sizeof(char));
int p = 0;
while(list->items[pos][p]!='\0')
{
ptr[p] = list->items[pos][p];
p++;
}
ptr[p] = '\0';
free(list->items[pos]);
if(pos == FIRST)
{
p = 1;
while(p <= list->counter)
{
list->items[p-1] = list->items[p];
p++;
}
}
else if(pos == list->counter)
{
int i = list->counter - 1;
p = 0;
while(p<=i)
{
list->items[p] = list->items[p];
p++;
}
}
else
{
p = 0;
int e = pos;
while(p<e)
{
list->items[p] = list->items[p];
p++;
}
p++;
list->items[e] = list->items[p];
p = 1;
while(pos+p < list->counter)
{
list->items[pos+p] = list->items[pos+p+1];
p++;
}
}
list->counter = list->counter - 1;
list->items = (char**)realloc(list->items,(list->counter+3-1)*sizeof(char*));
return ptr;
}
}
void Destroy_List(LIST* list) /* Funzionante */
{
int i = FIRST;
while(i <= list->counter)
{
free(list->items[i]);
i++;
}
free(list->items);
list->counter = -1;
}
_________________
Interventi di moderazione IN CORSIVO.
Cita:
[22:33:55] ShellCoder_ dice:
allora?
[22:34:03] DoMinO dice:
CAZZO STO FACENDO NA CASA :S
, ma itoa non è standard... sprintf lo è
