CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2012 05 27 18:27:40

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

LISTE CHAINÉE SIMPLE D'ENTIERS

Information sur la source

Note :

6,00 / 10

Catégorie :Maths & Algorithmes Niveau :Débutant Date de création :08/05/2003 Date de mise à jour :09/05/2003 06:22:38 Vu :7 768

Auteur : HeilongJiang

Ecrire un message privé

Commentaire sur cette source (7)

Ajouter un commentaire et/ou une note

Description

Manipulation de pointeurs à travers une liste chainée simple.
Liste d'entiers avec tri des valeurs par ordre croissant.
un menu permet de manipuler la liste.

Source

// liste_chainee.c
/* Programme d'apprentissage sur les pointeurs en langage C */
/* Liste chainee simple d'entiers avec tri croissant des valeurs */
/* De maniere a ajouter des valeurs en debut, fin et milieu de liste */
#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERR -1
#define QUIT 5 // valeur pour quitter le programme
// declaration maillon pour liste chainee simple
typedef struct _maillon_{
int valeur;
struct _maillon_* suivant;
}Maillon;
/* Retourne un pointeur sur le maillon nouvellement cree */
Maillon* creer_maillon(int valeur){
Maillon* maillon = NULL;
maillon = (Maillon*) malloc(sizeof(Maillon));
maillon->valeur = valeur;
maillon->suivant = NULL;
return(maillon);
}
/* Parcours la liste depuis le 1er maillon
et retourne le dernier maillon de la liste */
Maillon* dernier_maillon(Maillon* entete){
while(entete->suivant != NULL)
entete = entete->suivant;
return(entete);
}
/* Retourne OK si la valeur existe dans la liste, ERR sinon */
int maillon_recherche(Maillon* entete, int valeur){
while((entete->valeur != valeur) && (entete->suivant != NULL))
entete = entete->suivant;
if(entete->valeur == valeur)
return(OK);
else
return(ERR);
}
/* Ajoute le maillon nouvellement cree en tete de liste si la valeur actuelle du maillon en tete de liste est superieure a la valeur du nouveau maillon.
Retourne un pointeur sur le maillon en tete de liste */
Maillon* ajoute_maillon_entete(Maillon* entete, Maillon* nouveau){
if(entete != NULL){
nouveau->suivant = entete;
entete = nouveau;
return(entete);
}
return(NULL);
}
/* Ajoute le maillon nouvellement cree en queue de liste si la valeur actuelle du maillon en queue de liste est inferieur ou egal a la valeur du nouveau maillon.
Retourne un pointeur sur le maillon en queue de liste */
Maillon* ajoute_maillon_enqueue(Maillon* enqueue, Maillon* nouveau){
if(enqueue != NULL){
enqueue->suivant = nouveau;
return(nouveau);
}
return(NULL);
}
/* Ajoute le maillon nouvellement cree entre le maillon de valeur immediatement inferieure ou egal et le maillon de valeur immediatement superieure */
int ajoute_maillon_milieu(Maillon* entete, Maillon* nouveau){
Maillon* suivant;
suivant = entete->suivant;
if((entete != NULL) && (suivant != NULL)){
while((entete->valeur <= nouveau->valeur) &&
(suivant->valeur < nouveau->valeur)){
entete = entete->suivant;
suivant = entete->suivant;
}
if(suivant->valeur > nouveau->valeur){
nouveau->suivant = suivant;
entete->suivant = nouveau;
return(OK);
}
}
return(ERR);
}
/* Retourne un pointeur sur le maillon en tete de liste, NULL si la liste est vide ou si l'unique maillon de la liste est supprime */
Maillon* supprime_maillon(Maillon* precedent, int valeur){
Maillon* encours;
Maillon* suivant;
Maillon* liste;
if(precedent != NULL){
if(precedent->valeur == valeur){
if(precedent->suivant != NULL){
encours = precedent->suivant;
liste = encours;
free(precedent);
return(liste);
}else{
free(precedent);
return(NULL);
}
}
liste = precedent;
encours = precedent->suivant;
suivant = encours->suivant;
while(encours->valeur != valeur){
precedent = encours;
encours = suivant;
suivant = suivant->suivant;
}
if(encours->valeur == valeur){
precedent->suivant = suivant;
free(encours);
return(liste);
}
}
return(NULL);
}
/* affiche les valeurs de la liste */
int affiche_liste(Maillon* affiche){
while(affiche != NULL){
printf("%d, ", affiche->valeur);
affiche = affiche->suivant;
}
return(OK);
}
/* Retourne le choix de l'utilisateur */
int menu(void){
int choix = 0;
puts("");
puts("1. Ajouter un maillon");
puts("2. Supprimer un maillon");
puts("3. Rechercher un maillon");
puts("4. Afficher la liste");
puts("5. Quitter");
printf("Entrez un choix : ");
scanf("%d", &choix);
return(choix);
}
/* Retourne la valeur dans le cas d'un(e) ajout/suppression/recherche d'un maillon */
int navigation(int choix){
int valeur = 0;
switch(choix){
case 1: // l'utilisateur ajoute un maillon a la liste
printf("Entrez la valeur a ajouter : ");
scanf("%d", &valeur);
break;
case 2: // l'utilisateur supprime un maillon de la liste
printf("Entrez la valeur a supprimer : ");
scanf("%d", &valeur);
break;
case 3: // l'utilisateur recherche un maillon dans la liste
printf("Entrer la valeur a rechercher : ");
scanf("%d", &valeur);
break;
}
return(valeur);
}
int main(void){
Maillon* entete = NULL; // pointe sur le 1er maillon (declare a NULL)
Maillon* enqueue; // pointe sur le dernier maillon
Maillon* nouveau; // designe le maillon nouvellement cree
int valeur = 0;
int choix = 0;
int etat = 0;
choix = menu();
// tant que l'utilisateur ne quitte pas
while(choix != QUIT){
if((choix > 1) && (entete == NULL))
puts("La liste est vide");
else{
valeur = navigation(choix);
switch(choix){
case 1: // Ajout d'un maillon
nouveau = creer_maillon(valeur);
if(entete != NULL){
if(nouveau->valeur < entete->valeur)
// Ajout du maillon en tete de liste
entete = ajoute_maillon_entete(entete, nouveau);
else{
enqueue = dernier_maillon(entete);
if(nouveau->valeur >= enqueue->valeur)
// Ajout d'un maillon en queue de liste
enqueue = ajoute_maillon_enqueue(enqueue, nouveau);
else if((nouveau->valeur >= entete->valeur) &&
(nouveau->valeur < enqueue->valeur))
ajoute_maillon_milieu(entete, nouveau);
}
}else // entete == NULL --> 1er maillon ajoute a la liste
entete = nouveau;
break;
case 2: // Suppression d'un maillon
if(entete != NULL){
if(maillon_recherche(entete, valeur) == OK){
entete = supprime_maillon(entete, valeur);
if(entete == NULL)
free(entete);
}else
puts("La valeur n\'existe pas dans la liste");
}else
puts("La liste est vide.\n");
break;
case 3: // Recherche d'un maillon
etat = maillon_recherche(entete, valeur);
if(etat == ERR)
puts("la valeur n\'existe pas dans la liste");
else
printf("la valeur recherchee a ete trouve : %d\n", valeur);
break;
case 4:
affiche_liste(entete);
break;
}
}
choix = menu(); // re-init
}
return(EXIT_SUCCESS);
}

// liste_chainee.c
/* Programme d'apprentissage sur les pointeurs en langage C */
/* Liste chainee simple d'entiers avec tri croissant des valeurs */
/* De maniere a ajouter des valeurs en debut, fin et milieu de liste */

#include <stdio.h>
#include <stdlib.h>

#define OK 1 
#define ERR -1
#define QUIT 5 // valeur pour quitter le programme

// declaration maillon pour liste chainee simple
typedef struct _maillon_{
  int valeur;
  struct _maillon_* suivant;
}Maillon;

/* Retourne un pointeur sur le maillon nouvellement cree */
Maillon* creer_maillon(int valeur){
  Maillon* maillon = NULL;

  maillon = (Maillon*) malloc(sizeof(Maillon));
  maillon->valeur = valeur;
  maillon->suivant = NULL;
  return(maillon);
}

/* Parcours la liste depuis le 1er maillon 
   et retourne le dernier maillon de la liste */
Maillon* dernier_maillon(Maillon* entete){

 while(entete->suivant != NULL)
   entete = entete->suivant;
 return(entete);
}

/* Retourne OK si la valeur existe dans la liste, ERR sinon */
int maillon_recherche(Maillon* entete, int valeur){

  while((entete->valeur != valeur) && (entete->suivant != NULL))
       entete = entete->suivant;  
  if(entete->valeur == valeur)
    return(OK);
  else
    return(ERR);
}

/* Ajoute le maillon nouvellement cree en tete de liste si la valeur actuelle du maillon en tete de liste est superieure a la valeur du nouveau maillon.
Retourne un pointeur sur le maillon en tete de liste */
Maillon* ajoute_maillon_entete(Maillon* entete, Maillon* nouveau){
 
  if(entete != NULL){
    nouveau->suivant = entete;
   entete = nouveau;
    return(entete);
  }
  return(NULL);  
}

/* Ajoute le maillon nouvellement cree en queue de liste si la valeur actuelle du maillon en queue de liste est inferieur ou egal a la valeur du nouveau maillon.
Retourne un pointeur sur le maillon en queue de liste */
Maillon*  ajoute_maillon_enqueue(Maillon* enqueue, Maillon* nouveau){
  
  if(enqueue != NULL){
    enqueue->suivant = nouveau;
    return(nouveau);
  }
  return(NULL);
    
}

/* Ajoute le maillon nouvellement cree entre le maillon de valeur immediatement inferieure ou egal et le maillon de valeur immediatement superieure */
int ajoute_maillon_milieu(Maillon* entete, Maillon* nouveau){
  Maillon* suivant;

  suivant = entete->suivant;
  if((entete != NULL) && (suivant != NULL)){
    while((entete->valeur <= nouveau->valeur) &&
	  (suivant->valeur < nouveau->valeur)){
      entete = entete->suivant;
      suivant = entete->suivant;
    }
    if(suivant->valeur > nouveau->valeur){
      nouveau->suivant = suivant;
      entete->suivant = nouveau;
      return(OK);
    }
  }
  return(ERR);
}

/* Retourne un pointeur sur le maillon en tete de liste, NULL si la liste est vide ou si l'unique maillon de la liste est supprime */
Maillon* supprime_maillon(Maillon* precedent, int valeur){
  Maillon* encours;
  Maillon* suivant;
  Maillon* liste;

  if(precedent != NULL){
    if(precedent->valeur == valeur){
      if(precedent->suivant != NULL){
        encours = precedent->suivant;
	liste = encours;
        free(precedent);
        return(liste);
      }else{
	free(precedent);
        return(NULL);
      }
    }
    liste = precedent;
    encours = precedent->suivant;
    suivant = encours->suivant;
    while(encours->valeur != valeur){
      precedent = encours;
      encours = suivant;
      suivant = suivant->suivant;
    }
    if(encours->valeur == valeur){
      precedent->suivant = suivant;
      free(encours);
      return(liste);
    }
  }
  return(NULL);
}
  
/* affiche les valeurs de la liste */
int affiche_liste(Maillon* affiche){

  while(affiche != NULL){
    printf("%d, ", affiche->valeur);
    affiche = affiche->suivant;
  }
  return(OK);
}

/* Retourne le choix de l'utilisateur */
int menu(void){
  int choix = 0;

  puts("");
  puts("1. Ajouter un maillon");
  puts("2. Supprimer un maillon");
  puts("3. Rechercher un maillon");
  puts("4. Afficher la liste");
  puts("5. Quitter");
  printf("Entrez un choix : ");
  scanf("%d", &choix);
  return(choix);
}

/* Retourne la valeur dans le cas d'un(e) ajout/suppression/recherche d'un maillon */
int navigation(int choix){
  int valeur = 0;

  switch(choix){
  case 1: // l'utilisateur ajoute un maillon a la liste
    printf("Entrez la valeur a ajouter : ");
    scanf("%d", &valeur);
    break;
  case 2: // l'utilisateur supprime un maillon de la liste
    printf("Entrez la valeur a supprimer : ");
    scanf("%d", &valeur);
    break;
  case 3: // l'utilisateur recherche un maillon dans la liste
    printf("Entrer la valeur a rechercher : ");
    scanf("%d", &valeur);
    break;
  }
  return(valeur);
}

int main(void){
  Maillon* entete = NULL; // pointe sur le 1er maillon (declare a NULL)
  Maillon* enqueue; // pointe sur le dernier maillon
  Maillon* nouveau; // designe le maillon nouvellement cree

  int valeur = 0;
  int choix = 0;
  int etat = 0;

  choix = menu();
  // tant que l'utilisateur ne quitte pas
  while(choix != QUIT){
    if((choix > 1) && (entete == NULL))
      puts("La liste est vide");
    else{
      valeur = navigation(choix);
      switch(choix){
        case 1: // Ajout d'un maillon
          nouveau = creer_maillon(valeur);
          if(entete != NULL){
            if(nouveau->valeur < entete->valeur)
              // Ajout du maillon en tete de liste
              entete = ajoute_maillon_entete(entete, nouveau); 
            else{
	      enqueue = dernier_maillon(entete);
	      if(nouveau->valeur >= enqueue->valeur)
                // Ajout d'un maillon en queue de liste
	        enqueue = ajoute_maillon_enqueue(enqueue, nouveau);
	      else if((nouveau->valeur >= entete->valeur) &&
		      (nouveau->valeur < enqueue->valeur))
	        ajoute_maillon_milieu(entete, nouveau);
	    }
          }else // entete == NULL --> 1er maillon ajoute a la liste
           entete = nouveau;
          break;
        case 2: // Suppression d'un maillon
	  if(entete != NULL){
	    if(maillon_recherche(entete, valeur) == OK){
	      entete = supprime_maillon(entete, valeur);
	      if(entete == NULL)
		free(entete);
	    }else
	      puts("La valeur n\'existe pas dans la liste");
	  }else
	    puts("La liste est vide.\n");
	  break;
        case 3: // Recherche d'un maillon
          etat = maillon_recherche(entete, valeur);
          if(etat == ERR)
            puts("la valeur n\'existe pas dans la liste");
          else
            printf("la valeur recherchee a ete trouve : %d\n", valeur);
          break;
        case 4:
          affiche_liste(entete);
        break;
      }
    }
      choix = menu(); // re-init
  }
  return(EXIT_SUCCESS);
}

Sources du même auteur

LISTE DOUBLEMENT CHAINÉE D'ENTIERS

Toutes les sources de HeilongJiang

Sources de la même categorie

UN EXAMPLE D'APPLICATION EN CUDA DE L'ALGORITHME DE SCAN POU... par oguzaras

CHIFFREMENT DE VIGENERE par lajouad

ANALYSE SYNTAXIQUE par lajouad

STRUCTURE D'UNE MATRICE PAR LES LISTE LINÉAIRE (NON CONTUGUS... par benzarabel

DESSINER UNE ARBRE BINAIRE( MODE CONSOLE): par benzarabel

Toutes les sources de la catégorie Maths & Algorithmes

Commentaires et avis

Commentaire de BumpMANN le 16/12/2003 18:31:29

cool!

Commentaire de quanganh le 12/02/2004 05:58:27

help me

3.1. Ecriture d'une liste chaînée

Le C++ est un langage modulaire qui permet d'écrire des classes ré-utilisables. Si l'on doit réaliser une liste chaînée d'étudiants, une liste chaînée d'enseignants, etc., il serait peut-être intéressant d'isoler tous les mécanismes de gestion d'une liste chaînée pour pouvoir les réutiliser. C'est ce que nous allons faire. Toute liste chaînée est composée de deux parties :

Les éléments qui constituent les maillons de la liste chaînée. Pour cela, vous devez créer une classe Element.
Le mécanisme de gestion des éléments et des liens entre les éléments que vous stockerez dans une classe Liste.

3.1.1. Ecrire la classe Element

Tout élément d'une liste chaînée est caractérisé par :

son contenu. Si nous souhaitons pouvoir faire des listes d'étudiants, d'enseignants, etc., il faut ne faut pas que ce contenu soit typé. Vous utiliserez donc le type void* qui représente un type quelconque. Vous aurez donc un attribut du type void * contenu ;
le pointeur vers l'élément suivant. Ce pointeur sera donc de type Element *.
3.1.2. Ecrire la classe Liste

Cette classe modélise une liste chaînée d'Elements. Elle est caractérisée par un pointeur sur le premier élément de la liste et un pointeur sur l'élément courant. Cette classe contient toutes les méthodes nécessaires à la gestion d'une liste chaînée d'Elements (Ajouter, Supprimer, FinListe, Premier, Prochain).

3.2. Ecrire la classe ListeEnseignant

Cette classe permettra de stocker l'ensemble des enseignants de l'université. Puisque nous avons défini une classe Liste générique, nous pouvons la réutiliser. Pour cela, vous pouvez et devez considérer que la ListeEnseignant "est une" Liste. Ainsi, grâce à un lien d'héritage, votre classe ListeEnseignant dispose de tous les éléments nécessaires à une gestion d'une liste chaînée. Vous devez rajouter à cette classe tous les éléments qui sont propres à la gestion d'enseignants comme par exemple, ajouter un enseignant dans la liste, supprimer un enseignant de la liste, . plus une méthode de GestionListeEnseignant permettant d'afficher un menu pour le choix entre les différentes fonctionnalités.

3.3. Ecrire la classe ListeUV

3.4. Ecrire la classe Universite

Cette classe devra comprendre :

Une liste d'UV
Une liste d'enseignants
Toutes les méthodes que vous trouverez utiles
Une méthode GestionUniversité contenant le menu permettant d'accéder à la gestion des différentes composantes de la classe (gestion des étudiants, gestion des enseignants.)
3.5. Ecrire le programme principal

Ecrire un programme principal qui permette de créer une université et de lancer la gestion de l'université.

Commentaire de quanganh le 12/02/2004 05:58:28

Commentaire de quanganh le 12/02/2004 05:58:35

Commentaire de BumpMANN le 12/02/2004 07:53:22

waou! le triple posting! :O

Commentaire de misterzinzin le 25/10/2004 23:13:45

bonjour, j'essaye de faire une liste liée en c mais... j'y arrive pas... en fait le compilateur (borland 4.5) me retourne un erreur que je n'arrive pas a resoudre :
Pointer to structure required on left side of -> or ->* in function encode si qq pouvais me dire ou je me suis trompé, ca m'aiderais enormement.

le code est le suivant:

#include <stdio.h>
#include <string.h>
#include <alloc.h>

typedef struct _fiche{char nom[25],num[15];struct _fiche*suivant;} fiche;
int menu(void);
void encode(char* nom,char* numero,fiche** debut);
void recherche(char* nom/*,char* numero*/,fiche** debut);
void main(){
int choix;
fiche *debut;
char nom[25],numero[15];
debut=NULL;
printf("\nAdresse de debut: %p\n",&debut);

do{
choix=menu();
switch (choix){
case 1: printf("\nENCODAGE\n");
do {printf("Nom:");fgets(nom,25,stdin);nom[strlen(nom)-1]=0;}
while (nom[0]==0);
do {printf("Numero:");fgets(numero,15,stdin);numero[strlen(numero)-1]=0;}
while (numero[0]==0);
encode(nom,numero,&debut);
break;
case 2: printf("\nRECHERCHE\n");
do {printf("Nom:");fgets(nom,25,stdin);nom[strlen(nom)-1]=0;}
while (nom[0]==0);
/*do {printf("Numero:");fgets(numero,15,stdin);numero[strlen(numero)-1]=0;}
while (numero[0]==0);*/
recherche(nom/*,numero*/,&debut);
break;
default: printf("\nFIN\n");
}
}
while(choix!=3);

}
void encode(char* nom,char* numero,fiche **ptr_debut){
printf("\nJ'encode %s avec le numero %s\ndans la file qui a comme adresse de debut:%p",nom,numero,*ptr_debut);
if (*ptr_debut==NULL) {
*ptr_debut=malloc(sizeof(fiche));
strcpy(*ptr_debut->nom,nom); //L ERREUR SE TROUVE A CETTE LIGNE
}
else{
*ptr_debut->suivant=malloc(sizeof(fiche)); //ET A CETTE LIGNE
}
}
void recherche(char* nom/*,char* numero*/,fiche** debut){
printf("\nJe recherche %s \ndans la file qui a comme adresse de debut:%p",nom,*debut);

}
int menu(){
int lechoix;
printf("\n1>Encoder\n2>Rechercher\n3>Quitter\nVotre choix ");
do scanf("%d",&lechoix);
while ((lechoix>3) && (lechoix<1));
return lechoix;
}

Commentaire de fce le 31/01/2006 16:59:57

Bonjour
j essaies de réaliser une liste chainée en utilisant le language C (turbo C) mais g deux erreurs au nivo de la compilation
Pour commencer jetez svp un coup d'oeuil sur le programme :
#include<stdio.h>
#include<stddef.h>
#include<stdlib.h>
#define Malloc(t) (t *)malloc(sizeof(t))
enum boolean {true, faulse};
typedef struct_noeud      //(1)
  { char nom[15];
    struct_noeud *suivant;} adh;

adh *creer(char *nom) //(2)
  {
    adh *tete; tete =NULL;
    adh *p;
    p=NULL;
    p=Malloc(adh);
    p->nom= nom;
    p->suivant=NULL;
    return(p);
  }
void inserer(adh *nom)
  {
  adh *tete;
  adh *p1;
  adh *p2;
  p1=tete; p2=NULL;
  while ((p1!= NULL) && (strcmp (nom, p1->nom) >0))
     {
      p2=p1;
      p1=p1->suivant;
     }
    if (p1==NULL)
p1=creer(nom);
else
{
p2=creer(nom);
p2->suivant=p1;
}
  }
void afficher()
{
  adh *p;
  p=tete;
  while(p) prrintf("%s -> %s", p, p->suivant);
}
boolean chercher(char *nom)
  {
  adh *tete;
  while ((tete-> nom != nom) && (tete -> suivant != NULL))
      tete=tete-> suivant;
   if (tete -> nom == nom)
       return(true);
       else return(faulse);
   }
adh * supprimer(adh *nom)
  {
    adh *pred, *p; boolean found;
    pred=NULL;
    p=NULL;
     if (tete==NULL) perror("liste vide");
else
  {
    if (tete-> nom==nom)
       {
p=tete; tete=tete->suivant;
free(p);
       }
     else
       {
found = chercher(nom);
if (! found) peror("pas dans la liste");
else
   {
     pred-> suivant= p-> suivant;
     free(p);
   }
return(tete);
}
    }
  }
void main()
{
...
...
}
le compilateur affiche les erreur suivante
  ' , expected' voir (1)
  ' declaration syntax error' voir (2)
Svp aidez moi.
je vous remercies d'avance.

Ajouter un commentaire

Nos sponsors

Derniers Blogs

IMAGINE CUP 2012, MAKE A SIGN EN FINALE par junarnoalg

KINECT 1.5 IS OUT ! par Vko

LES ACTUALITéS DE LA SEMAINE SUR C2I.FR (14 MAI - 20 MAI) par richardc

REACTIVE EXTENSIONS : CONSOMMER DES SERVICES AVEC RX PARTIE 3, LES PIèGES à éVITER par Groc

SHAREPOINT BLOG SITE, PROBLèME D'ARCHIVES par junarnoalg

Forum

MATRICE TEMPLATE par hjr2610

SUPERVISION DE LA BATTERIE par romanticgirl

RE : OPENCV ET INTERFACE GRAPHIQUE VISUAL STUDIO par buno

RE : SAC A DOS par hadjkaddour

OPENCV ET INTERFACE GRAPHIQUE VISUAL STUDIO par ssaif

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Realisation d-une version 2 d-un site e-commerce existant sous prestashop-REPUBLICATION
Budget : 5 000€
Recherche Infogerance Serveur Debian Linux
Budget : 1 800€
Creation d-un site vitrine avec MagentO
Budget : 2 000€

Logiciels

sDEVIS-FACTURES vlPRO (8.1.0.3)
SDEVIS-FACTURES VLPRO (8.1.0.3)

sDEVIS-FACTURES vlPRO a été mis au point pour les particuliers, créateurs, entrepreneurs, artisa...

Cliquez pour télécharger sDEVIS-FACTURES vlPRO
974 Application Server (12.2.4.6)
974 APPLICATION SERVER (12.2.4.6)

Développez de puissantes applications dans un environnement de 'cloud computing', clusterisé, séc...

Cliquez pour télécharger 974 Application Server
vPicture (1.4.2.1)
VPICTURE (1.4.2.1)

Avec vPicture, hébergez vos images facilement et rapidement. vPicture est un utilitaire simple, ...

Cliquez pour télécharger vPicture
Easy-Planning (2.2.1.6)
EASY-PLANNING (2.2.1.6)

Easy-Planning permet de créer des plannings sous la représentation de diagrammes et est adapté au...

Cliquez pour télécharger Easy-Planning
COM-BACKUP (2.0)
COM-BACKUP (2.0)

COM-BACKUP est un logiciel de sauvegarde qui permet de planifier les sauvegardes de vos dossiers ...

Cliquez pour télécharger COM-BACKUP