Liste chainée

Marsh Posté le 22-06-2006 à 22:34:37

Bonjour,

J'ai besoin de conseils pour les listes chainées.
Mon programme fait ce que je veux, c'est à dire sauvegarde dans un fichier du login, pass et shell entré (option a) et liste (option l) ou efface (option d) (avec cryptage du mot de passe).

Mais voilà, je souhaiterai qu'il ne sauvegarde pas dans un fichier mais dans une liste chainée (donc en mémoire dynamique).

J'ai tenté de remplacer la structure ci dessous par quelque chose comme :
typedef struct Element{
int val;
struct Element *next;
}Element;
Mais j'ai trop d'erreurs.

Des idées ?

Code :

struct my_passwd
{
char pw_name[255]; /* user name */
char pw_passwd[255]; /* password */
char pw_shell[64]; /* default shell */
} ;
int woptions(int ac,char ***av)
{
int option2return;
option2return=getopt(ac, *av,"adl" );
if(getopt(ac,*av,"adl" ) != -1)
{
printf("my_passwd: usage -[adl] [file]\n" );
exit(EXIT_FAILURE);
}
else
return option2return;
}
int ajoututilisateur(char *fichier)
{
struct my_passwd pwd;
int fd;
MD5_CTX ctx;
memset(&pwd, 0,sizeof(pwd));
printf("Username: " );
scanf("%s",pwd.pw_name);
printf("Password: " );
scanf("%s",pwd.pw_passwd);
MD5Init(&ctx);
MD5Update(&ctx,pwd.pw_passwd,strlen(pwd.pw_passwd));
MD5End(&ctx,pwd.pw_passwd);
printf("Shell: " );
scanf("%s",pwd.pw_shell);
if((fd = open(fichier, O_RDWR|O_APPEND)) == -1)
{
perror("my_passwd" );
exit(EXIT_FAILURE);
}
if((write(fd, &pwd, sizeof(pwd))) == -1)
{
perror("my_passwd" );
exit(EXIT_FAILURE);
}
close(fd);
return 1;
}
int effaceutilisateur(char *fichier)
{
struct my_passwd pwd;
int fd;
int userexist=0;
char *nom;
int taille;
int totalsize=0;
nom=malloc(sizeof(char *));
memset(&pwd, 0,sizeof(pwd));
printf("Username: " );
scanf("%s",nom);
if((fd = open(fichier, O_RDWR)) == -1)
{
perror("my_passwd" );
exit(EXIT_FAILURE);
}
while((taille=read(fd,&pwd,sizeof(pwd))) != 0)
{
totalsize += taille;
if(strcmp(nom,pwd.pw_name) == 0)
{
while((taille=read(fd,&pwd,sizeof(pwd))) != 0)
{
lseek(fd,(totalsize-sizeof(pwd)),SEEK_SET);
if((write(fd, &pwd, sizeof(pwd))) == -1)
{
perror("my_passwd" );
exit(EXIT_FAILURE);
}
totalsize += taille;
lseek(fd,totalsize,SEEK_SET);
}
userexist=1;
}
}
close(fd);
if(userexist==0)
{
printf("my_passwd: unknown user %s\n",nom);
}
else
truncate(fichier,totalsize-sizeof(pwd));
return 1;
}
int listeutilisateur(char *fichier)
{
struct my_passwd pwd;
int fd;
char *nom;
memset(&pwd, 0,sizeof(pwd));
if((fd = open(fichier, O_RDWR)) == -1)
{
perror("my_passwd" );
exit(EXIT_FAILURE);
}
while((read(fd,&pwd,sizeof(pwd))) != 0)
{
printf("Username: %s\n",pwd.pw_name);
printf("Password: %s\n",pwd.pw_passwd);
printf("Shell: %s\n\n",pwd.pw_shell);
}
close(fd);
return 1;
}
int nbrconf(int ac)
{
if(ac!=3)
{
printf("my_passwd: usage -[adl] [file]\n" );
exit(EXIT_FAILURE);
}
else
return 1;
}
int fichierlu(char *fichier)
{
struct stat s_sb;
if(lstat(fichier,&s_sb) != 0)
{
perror("my_passwd" );
exit(EXIT_FAILURE);
}
else
{
if(!S_ISREG(s_sb.st_mode))
{
printf("my_passwd: need a file\n" );
printf("my_passwd: usage -[adl] [file]\n" );
}
else
return 1;
}
}
void priseoption(int choixoption, char *fichier)
{
switch (choixoption)
{
case 'a':
ajoututilisateur(fichier);
break;
case 'd':
effaceutilisateur(fichier);
break;
case 'l':
listeutilisateur(fichier);
break;
}
}
int main(int ac, char **av)
{
int choixoption;
extern int opterr;
opterr=0;
nbrconf(ac);
choixoption=woptions(ac,&av);
fichierlu(av[2]);
priseoption(choixoption,av[2]);
}

MERCI par avance

Message édité par mayapour le 23-06-2006 à 16:17:58

Reply

Marsh Posté le 22-06-2006 à 22:34:37

Reply

Marsh Posté le 23-06-2006 à 00:59:48

Hum... un peu compliqué.
Bon, avant toute chose, il faut savoir qu'une liste chaînée n'est utile que si tu dois insérer des éléments au-milieu d'autres. Avec une liste chaînée, tu crées un nouvel élément puis tu mets à jour les liens.
Si ton élément vient s'insérer après les autres, une liste chaînée marchera mais n'est vraiment pas utile et peut avantageusement être remplacée par un tableau que tu alloues et réalloue avec realloc dès que tu l'as remplis...

Remarque annexe: c'est pas très propre de mettre des "exit" dans des fonctions autre que "main"

Message cité 1 fois

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

Reply

Marsh Posté le 23-06-2006 à 15:42:59

Sve@r a écrit :

Bon, avant toute chose, il faut savoir qu'une liste chaînée n'est utile que si tu dois insérer des éléments au-milieu d'autres. Avec une liste chaînée, tu crées un nouvel élément puis tu mets à jour les liens.
Si ton élément vient s'insérer après les autres, une liste chaînée marchera mais n'est vraiment pas utile et peut avantageusement être remplacée par un tableau que tu alloues et réalloue avec realloc dès que tu l'as remplis...

Effectivement, mais je pense que dans ce cas, la liste chaînée se justifie pour les suppressions d'éléments (fonction effaceutilisateur).

mayapour> Ta définition de la structure Element me paraît pas mal, mais je ne comprends pas pourquoi val est un int et pas un my_passwd.
Tu devrais maintenant te construire une petite bibliothèque de fonctions permettant de manipuler tes listes chaînées (ajout, suppression, recherche). On t'aidera si tu as des problèmes pour ça.
Ensuite, il sera simple de reprendre tes fonctions existantes et les primitives de manipulation de listes pour faire ce que tu veux.

PS: utilise des balises code pour poster tes programmes stp.

EDIT: j'avais pas vu le topic doublon :spamafote:

Message cité 1 fois
Message édité par franceso le 23-06-2006 à 15:46:50

---------------
TriScale innov

Reply

Marsh Posté le 23-06-2006 à 16:53:00

franceso a écrit :

Effectivement, mais je pense que dans ce cas, la liste chaînée se justifie pour les suppressions d'éléments (fonction effaceutilisateur).

Exact. J'avais juste survolé le code sans fait gaffe à cette fonction. Effectivement, s'il y a insertion ou suppression d'un élément intermédiaire, la liste chaînée se justifie.

franceso a écrit :

mayapour> Ta définition de la structure Element me paraît pas mal, mais je ne comprends pas pourquoi val est un int et pas un my_passwd.
Tu devrais maintenant te construire une petite bibliothèque de fonctions permettant de manipuler tes listes chaînées (ajout, suppression, recherche). On t'aidera si tu as des problèmes pour ça.
Ensuite, il sera simple de reprendre tes fonctions existantes et les primitives de manipulation de listes pour faire ce que tu veux.

Très bonnes remarques. Je vais rajouter les miennes
1) en général, une structure se nomme conventionnellement "s_qqchose" => struct s_passwd" au lieu de "struct passwd"

2) utiliser "typedef" permet de ne plus être obligé de mettre "struct" chaque fois que tu veux avoir une variable de type "struct s_passwd"

typedef struct {
char pw_name[255]; /* user name */
char pw_passwd[255]; /* password */
char pw_shell[64]; /* default shell */
} t_passwd;

Ensuite, au-lieu de créer des variables de type "struct s_passwd", tu crées des variables de type "t_passwd" mais qui s'emploient de la même manière

3) après avoir défini ton type "t_elem" te permettant de manipuler un élément de ta liste, il est souvent judicieux de créer un type "t_liste" te permettant de manipuler toute ta liste entière.
Ce type (pouvant être vu comme "poignée de ta liste" ) contiendra évidemment un pointeur sur le premier élément, éventuellement un pointeur sur le dernier, un pointeur sur l'élément en cours de traitement, etc (tout ce qu'il peut te paraître utile d'avoir).
Ensuite, dans ton main, tu définis un "t_liste liste" et tu initialises tous ses pointeurs à NULL (autant créer une fonction "void ListeInit" pour faire cela) puis, dès que tu veux passer ta liste à une fonction quelconque, tu lui passes "&liste" et ta fonction recevant un pointeur de type "t_liste *" pourra, à partir de ce pointeur, manipuler à son grès chacun des éléments de ta liste.

En faisant comme Francesco le dit, en créant toute une foule de fonctions te permettant de manipuler un élément, ou une liste complète, tu te rapproches de la philosophie "objet" (un type + des fonctions pour le manipuler). Une fois que tes fonctions sont bien solides, la finalisation devient très simple.

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

Reply

Liste chainée

Sujets relatifs:

Leave a Replay