//OK
struct Noeud* supprimer(Arbre * Racine, int valeur)
{
struct Noeud* NoeudASupprimer;
if (Racine->valeur==valeur) // on a trouvé l'élément à supprimer
{
NoeudASupprimer=Racine;
if (NoeudASupprimer->gauche==NULL) //s'il n'y a pas de sous abre gauche, on retourne sous abre droit
{
return NoeudASupprimer->droit;
}
else
{
Racine=NoeudASupprimer->gauche; //sinon on recherche dans gauche l'endroit pour insérer le droit
while (Racine->droit!=NULL)
{
Racine=Racine->droit;
}
Racine->droit=NoeudASupprimer->droit;
return NoeudASupprimer->gauche;
}
free(NoeudASupprimer);
}
else
{
if (Racine->valeur>valeur)
{
Racine->gauche=supprimer(Racine->gauche,valeur);
}
else
{
Racine->droit=supprimer(Racine->droit,valeur);
}
}
return Racine;
}
/* un petit exemple d'utilisation */
int main(int argc, char **argv)
{ list_item *ma_liste;
list_item *vlist_move;
/* initialise la liste comme une liste vide (pas d'elements) */
ma_liste = NULL;
/* on rajoute la valeur 4 au debut de la liste */
ma_liste = inserer_debut(ma_liste, 4);
/* on rajoute la valeur 3 au debut de la liste */
ma_liste = inserer_debut(ma_liste, 3);
/* on rajoute la valeur 44 a la fin de la liste */
ma_liste = inserer_fin(ma_liste, 44);
/* on rajoute la valeur 5 a la fin de la liste */
ma_liste = inserer_fin(ma_liste, 5);
/* on supprime la valeur 44 de la liste */
ma_liste = supprimer(ma_liste, 44);
/* on parcours la liste pour en afficher le contenu */
for(vlist_move=ma_liste;vlist_move!=NULL;vlist_move=vlist_move->next)
{
printf("valeur %d\n",vlist_move->val);
}
return(0);
}
Elem *recup_min(Tas *tas)
{
Elem *e;
if(tas->nbNoeud == 0) {
//tas vide
e = NULL;
}
else {
e = tas->val[tas->tas[0]];
supprimer(tas, e);
}
return e;
}
Accueil::Accueil(QWidget* parent): QDialog(parent)
{
message = new QLabel("Etes vous sur de vouloir tout fermer ?", this);
valider = new QPushButton("Valider", this);
annuler = new QPushButton("Annuler", this);
coucheH1 = new QVBoxLayout;
coucheH1->addWidget(message);
coucheH2 = new QVBoxLayout;
coucheH2->addWidget(valider);
coucheH2->addWidget(annuler);
couche = new QHBoxLayout;
couche->addLayout(coucheH1);
couche->addLayout(coucheH2);
setLayout(couche);
connect(valider, SIGNAL(clicked()), this, SLOT(supprimer()));
connect(annuler, SIGNAL(clicked()), this, SLOT(close()));
}
int main (int argc, char ** argv){
char reponse ='0';
carnet * p;
carnet * d;
while( reponse!='5'){
printf("-----------------------------------\n");
printf("- \n");
printf("- CHOIX \n");
printf("- \n");
printf("-----------------------------------\n");
printf("1-Ajouter un contact \n");
printf("2-Supprimer un contact\n");
printf("3-Afficher tous mes contact\n");
printf("4-Enregistrement de la liste\n");
printf("5-Quitter\n");
printf("---------------------------------------\n");
scanf("\n%c", & reponse);
switch (reponse){
case '1':
d=creer_contact(p);
break;
case '2' :
d=supprimer(p);
break;
case'3':
affichage(d);
break;
case '4':
enregistrement(p);
break;
case '5':
return 0;
};
};
return 0;
}
int main() {
int k;
Liste_proc processus = NULL;
// Créer un premier processus
inserer(99, PRET, &processus);
// Créer 10 processus dans la liste
for(k = 0; k < 10; k++){
inserer(k, PRET, &processus);
}
// Afficher la liste de processus
afficher(processus);
// Modifier l'état des processus 1, 4, 7
modifierEtat(1, SUSPENDU, processus);
modifierEtat(4, SUSPENDU, processus);
modifierEtat(7, SUSPENDU, processus);
// Afficher à nouveau la liste de processus
afficher(processus);
// Afficher le pid du premier processus
printf("Le processus en tête a pour pid %d\n\n", lireNumTete(processus));
// Supprimer le processus 5
supprimer(5, &processus);
// Dire si les processus 99, 5, 7, 13 appartiennent aux processus listés
printf("%d : 99 est dans la liste des processus (1=true, 0=false)\n\n", appartient(99, processus));
printf("%d : 5 est dans la liste des processus (1=true, 0=false)\n\n", appartient(5, processus));
printf("%d : 7 est dans la liste des processus (1=true, 0=false)\n\n", appartient(7, processus));
printf("%d : 13 est dans la liste des processus (1=true, 0=false)\n\n", appartient(13, processus));
return 0;
}
/**
* @brief Constructeur
*
* Ce constructeur initialise toutes les fonctions de l'Interface Graphique de cette fenêtre : créer et organiser les
* objets graphiques, et les connecter avec les bons slots.
*/
UVWindow::UVWindow() {
setWindowTitle("UTProfiler");
mainlayout = new QVBoxLayout();
hlayout1 = new QHBoxLayout();
pbretour = new QPushButton("Retour");
lcode = new QLabel("Code : ");
lecode = new QLineEdit();
pbrechercher = new QPushButton("Rechercher");
lresponsable = new QLabel("Responsable : ");
leresponsable = new QLineEdit();
hlayout1->addWidget(pbretour);
hlayout1->addWidget(lcode);
hlayout1->addWidget(lecode);
hlayout1->addWidget(pbrechercher);
hlayout1->addWidget(lresponsable);
hlayout1->addWidget(leresponsable);
hlayout2 = new QHBoxLayout();
tedescription = new QTextEdit();
vlayout21 = new QVBoxLayout();
hlayout211 = new QHBoxLayout();
lprintemps = new QLabel("Printemps : ");
cbprintemps = new QCheckBox();
hlayout211->addWidget(lprintemps);
hlayout211->addWidget(cbprintemps);
hlayout212 = new QHBoxLayout();
lautomne = new QLabel("Automne : ");
cbautomne = new QCheckBox();
hlayout212->addWidget(lautomne);
hlayout212->addWidget(cbautomne);
vlayout21->addLayout(hlayout211);
vlayout21->addLayout(hlayout212);
hlayout2->addWidget(tedescription);
hlayout2->addLayout(vlayout21);
hlayout3 = new QHBoxLayout();
lcs = new QLabel("CS : ");
lecs = new QLineEdit();
ltm = new QLabel("TM : ");
letm = new QLineEdit();
ltsh = new QLabel("TSH :");
letsh = new QLineEdit();
lsp = new QLabel("SP : ");
lesp = new QLineEdit();
hlayout3->addWidget(lcs);
hlayout3->addWidget(lecs);
hlayout3->addWidget(ltm);
hlayout3->addWidget(letm);
hlayout3->addWidget(ltsh);
hlayout3->addWidget(letsh);
hlayout3->addWidget(lsp);
hlayout3->addWidget(lesp);
hlayout4 = new QHBoxLayout();
ltc = new QLabel("TC : ");
cbtc = new QCheckBox();
lhutech = new QLabel("HUTECH : ");
cbhutech = new QCheckBox();
lgb = new QLabel("GB : ");
cbgb = new QCheckBox();
lgi = new QLabel("GI : ");
cbgi = new QCheckBox();
lgm = new QLabel("GM : ");
cbgm = new QCheckBox();
lgp = new QLabel("GP : ");
cbgp = new QCheckBox();
lgsm = new QLabel("GSM : ");
cbgsm = new QCheckBox();
lgsu = new QLabel("GSU : ");
cbgsu = new QCheckBox();
hlayout4->addWidget(ltc);
hlayout4->addWidget(cbtc);
hlayout4->addWidget(lhutech);
hlayout4->addWidget(cbhutech);
hlayout4->addWidget(lgb);
hlayout4->addWidget(cbgb);
hlayout4->addWidget(lgi);
hlayout4->addWidget(cbgi);
hlayout4->addWidget(lgm);
hlayout4->addWidget(cbgm);
hlayout4->addWidget(lgp);
hlayout4->addWidget(cbgp);
hlayout4->addWidget(lgsm);
hlayout4->addWidget(cbgsm);
hlayout4->addWidget(lgsu);
hlayout4->addWidget(cbgsu);
hlayout5 = new QHBoxLayout();
pbnouveau = new QPushButton("Nouveau");
pbsupprimer = new QPushButton("Supprimer");
pbsauver = new QPushButton("Sauver");
hlayout5->addWidget(pbnouveau);
hlayout5->addWidget(pbsupprimer);
hlayout5->addWidget(pbsauver);
mainlayout->addLayout(hlayout1);
mainlayout->addLayout(hlayout2);
mainlayout->addLayout(hlayout3);
mainlayout->addLayout(hlayout4);
mainlayout->addLayout(hlayout5);
this->setLayout(mainlayout);
QObject::connect(pbretour,SIGNAL(clicked()),this,SLOT(close()));
QObject::connect(pbsupprimer,SIGNAL(clicked()),this,SLOT(supprimer()));
QObject::connect(pbnouveau,SIGNAL(clicked()),this,SLOT(nouveau()));
QObject::connect(lecode,SIGNAL(returnPressed()),this,SLOT(rechercher()));
QObject::connect(pbrechercher,SIGNAL(clicked()),this,SLOT(rechercher()));
QObject::connect(pbsauver,SIGNAL(clicked()),this,SLOT(sauver()));
QObject::connect(leresponsable,SIGNAL(textChanged(QString)),this,SLOT(pbsauverEnable()));
QObject::connect(tedescription,SIGNAL(textChanged()),this,SLOT(pbsauverEnable()));
QObject::connect(lecs,SIGNAL(textChanged(QString)),this,SLOT(pbsauverEnable()));
QObject::connect(letm,SIGNAL(textChanged(QString)),this,SLOT(pbsauverEnable()));
QObject::connect(letsh,SIGNAL(textChanged(QString)),this,SLOT(pbsauverEnable()));
QObject::connect(lesp,SIGNAL(textChanged(QString)),this,SLOT(pbsauverEnable()));
QObject::connect(cbprintemps,SIGNAL(stateChanged(int)),this,SLOT(pbsauverEnable()));
QObject::connect(cbautomne,SIGNAL(stateChanged(int)),this,SLOT(pbsauverEnable()));
QObject::connect(cbtc,SIGNAL(stateChanged(int)),this,SLOT(pbsauverEnable()));
QObject::connect(cbhutech,SIGNAL(stateChanged(int)),this,SLOT(pbsauverEnable()));
QObject::connect(cbgb,SIGNAL(stateChanged(int)),this,SLOT(pbsauverEnable()));
QObject::connect(cbgi,SIGNAL(stateChanged(int)),this,SLOT(pbsauverEnable()));
QObject::connect(cbgm,SIGNAL(stateChanged(int)),this,SLOT(pbsauverEnable()));
QObject::connect(cbgp,SIGNAL(stateChanged(int)),this,SLOT(pbsauverEnable()));
QObject::connect(cbgsm,SIGNAL(stateChanged(int)),this,SLOT(pbsauverEnable()));
QObject::connect(cbgsu,SIGNAL(stateChanged(int)),this,SLOT(pbsauverEnable()));
}
int main(int argc, char** argv)
{
/*variables locales*/
login_t * ptete;
login_t * ajout;
int confirm = 1;
char demande_ajout_t;
char demande_position_t;
/*allocation du pointeur vers le premier élement de la structure*/
ptete = (login_t *) malloc (sizeof(login_t));
(*ptete).suivant = NULL;
/*initialisation des éléments*/
initialiser(ptete);
while (confirm == 1)
{
/*demande/choix entre la modif ou la création d'un compte*/
printf("Voulez-vous ajouter, supprimer un compte ou ne rien faire ? (a/s/f) ");
fflush(stdout);
scanf("%s%*c",&demande_ajout_t);
if ((demande_ajout_t == 'a') && (strcmp("vide", (*ptete).nom_de_login) == 0))
{
/*ajout d'un compte sur un élément vide*/
saisie(ptete);
}
else if (demande_ajout_t == 'a')
{
/*ajout d'un compte par création d'un élément*/
ajout = (login_t *) malloc(sizeof(login_t));
if (ajout == NULL)
{
printf("Erreur d'allocation");
}
else
{
/*saisie du compte*/
saisie(ajout);
/*ajout du compte au gestionnaire*/
printf("Voulez-vous ajouter le compte en fin, au milieu ou au debut (f/n/d) ? ");
fflush(stdout);
scanf("%c%*c", &demande_position_t);
if (demande_position_t == 'f')
{
inserFin(ptete,&ajout);
}
else if (demande_position_t == 'd')
{
inserTete(&ptete,&ajout);
}
else if (demande_position_t == 'm')
{
inserMilieu(ptete,&ajout);
}
}
}
else if (demande_ajout_t == 's')
{
supprimer(&ptete);
}
else
{
confirm = 0;
}
}
/*affichage des élements*/
affichage(ptete);
/*libération de la mémoire allouée*/
liberation(&ptete);
return 0;
}
/**
* @brief Résout un puzzle
* @param[in,out] p le puzzle à résoudre
* @param[in] t le damier initial
* @param[in,out] os flux de sortie
*/
void jouer(Puzzle& p, const Tab2D& t, std::ostream& os) {
Etat etatInitial;
Etat etatCourant;
Tab2D damierFinal;
Etat etatDerive;
double tempsDebutRecherche = getTime();
but(damierFinal, t.nbL, t.nbC);
initialiser(etatInitial.damier, t.nbL, t.nbC);
etatInitial.mouvement = FIXE;
etatInitial.precedent = 0;
etatInitial.g = 0;
//Copie du damier inititial dans etatInitial
for (unsigned int l = 0; l < t.nbL; ++l) {
for (unsigned int c = 0; c < t.nbC; ++c) {
etatInitial.damier.tab[l][c] = t.tab[l][c];
}
}
etatInitial.h = manhattan(etatInitial.damier, damierFinal);
initialiser(etatDerive.damier, t.nbL, t.nbC);
inserer(p.lEAE, 0, etatInitial); //étatInitial dans LEAE
bool solutionTrouvee = false;
bool mvtPossible;
unsigned int pos;
while (p.lEAE.nb != 0) {
pos = minimal(p.lEAE);
etatCourant = lire(p.lEAE, pos); //on prend le 1er état à explorer
//insérer étatCourant dans LEE
inserer(p.lEE, longueur(p.lEE), etatCourant);
supprimer(p.lEAE, pos); //supprimer étatCourant de LEAE
if (etatCourant.h == 0) { // le damier de étatCourant est le damier but
solutionTrouvee = true;
break; //sortir de la boucle while
}
/*pour_tout (mouvement possible associé à étatCourant)
mouvement possible relatif à damier de étatCourant (etatCourant.damier)
ordre d'exploration (obligatoire) NORD, EST, SUD, OUEST */
//initialiser un étatDérivé // d'après le mouvement
for(int m = OUEST; m >= NORD; --m) {
mvtPossible = deriver(etatCourant, (Mouvement) m, etatDerive);
if (mvtPossible && !rechercher(etatDerive, p.lEAE)\
&& !rechercher(etatDerive, p.lEE)) {
etatDerive.precedent = longueur(p.lEE) - 1;
etatDerive.h = manhattan(etatDerive.damier, damierFinal);
etatDerive.g = etatCourant.g + 1;
//insérer étatDérivé dans LEAE
inserer(p.lEAE, longueur(p.lEAE), etatDerive);
}
}
}
double tempsFinRecherche = getTime();
cout << "Durée de recherche : " << tempsFinRecherche - tempsDebutRecherche
<<" seconde(s)."<< endl;
if (solutionTrouvee) {
Pile sol;
Etat etatSol;
initialiser(sol, 3, 2);
initialiser(etatSol.damier, t.nbL, t.nbC);
//Stockage de la solution
etatSol = lire(p.lEE, longueur(p.lEE)-1);
empiler(sol, etatSol);
while (etatSol.precedent != 0) {
etatSol = lire(p.lEE, etatSol.precedent);
empiler(sol, etatSol);
}
empiler(sol, etatInitial);
//Affichage de la solution
os << "Damier : " << t.nbL << " lignes " << t.nbC << " colonnes"
<< endl;
os << "Solution en " << sol.sommet << " mouvements" << endl;
while (!estVide(sol)) {
afficher(sommet(sol), os);
os << endl;
depiler(sol);
}
detruire(sol);
detruire(etatSol.damier);
}
else {
os << "Solution non trouvée" << endl;
}
detruire(etatInitial.damier);
detruire(etatCourant.damier);
detruire(etatDerive.damier);
detruire(damierFinal);
}
int main(int argc, char ** argv){
struct timeval start, end;
Liste * fichiers = fichiers_reguliers(SHAKESPEARE_DIR);
Liste * mots;
char * fichier;
TrieHybride * t = NULL;
int i,fd,fd2,arg_fusion,res;
double res_d;
char buff[128];
pthread_t tid[NB_THREADS];
pthread_attr_t attr;
briandais_t * br;
/****************************************************************************
BENCHMARK INSERTION NON MULTITHREADE
****************************************************************************/
printf("Insertion de toutes les pieces de Shakespeare \t\t: En cours ...");
fflush(stdout);
temps(&start);
while((fichier=supprimer_debut(fichiers))){
t=lire_fichier_th(fichier,t);
free(fichier);
}
temps(&end);
afficher_res(start,end);
destroy_liste(fichiers);
/****************************************************************************
SUPPRESSION MOTS HAMLET
****************************************************************************/
printf("Suppression des mots de la piece \"Hamlet\" \t\t: En cours ...");
fflush(stdout);
fd=ouvrir_fichier(SHAKESPEARE_DIR"hamlet.txt");
if(fd<0){
perror("ouverture fichier");
exit(EXIT_FAILURE);
}
temps(&start);
while(mot_suivant(fd,buff)>0){
t=supprimer(t,buff);
}
temps(&end);
afficher_res(start,end);
if(close(fd)==-1){
perror("close");
exit(EXIT_FAILURE);
}
/****************************************************************************
RECHERCHE ALL'S WELL & HAMLET
****************************************************************************/
printf("Recherche des mots de All's Well et Hamlet \t\t: En cours ...");
fflush(stdout);
fd=ouvrir_fichier(SHAKESPEARE_DIR"hamlet.txt");
if(fd<0){
perror("ouverture fichier");
exit(EXIT_FAILURE);
}
fd2=ouvrir_fichier(SHAKESPEARE_DIR"allswell.txt");
if(fd2<0){
perror("ouverture fichier");
exit(EXIT_FAILURE);
}
temps(&start);
while(mot_suivant(fd,buff)>0){
recherche_trie_hybride(t,buff);
}
while(mot_suivant(fd2,buff)>0){
recherche_trie_hybride(t,buff);
}
temps(&end);
afficher_res(start,end);
if(close(fd)==-1){
perror("close");
exit(EXIT_FAILURE);
}
if(close(fd2)==-1){
perror("close");
exit(EXIT_FAILURE);
}
/****************************************************************************
DESTRUCTION TRIE HYBRIDE
****************************************************************************/
printf("Destruction du trie hybride \t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
free_trie_hybride(t);
temps(&end);
afficher_res(start,end);
/****************************************************************************
CREATION SHAKESPEARE MULTITHREADE
****************************************************************************/
fics=fichiers_reguliers(SHAKESPEARE_DIR);
tries=creer_liste();
sem_init(&sem,1,0);
arg_fusion=fics->taille;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
printf("Insertion multithreade des oeuvres de Shakespeare\t: En cours ...");
fflush(stdout);
temps(&start);
pthread_mutex_lock(&mutex_fics);
for(i=0;i<NB_THREADS-1;i++){
if(pthread_create(&(tid[i]),&attr,creation_trie_thread,NULL)==-1){
perror("pthread_create");
exit(EXIT_FAILURE);
}
}
if(pthread_create(&(tid[NB_THREADS-1]),&attr,fusion_thread,&arg_fusion)==-1){
perror("pthread_create");
exit(EXIT_FAILURE);
}
pthread_cond_wait(&cond,&mutex_fics);
temps(&end);
afficher_res(start,end);
destroy_liste(fics);
t=supprimer_debut(tries);
destroy_liste(tries);
/****************************************************************************
COMPTAGE MOTS
****************************************************************************/
printf("Comptage des mots \t\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res=comptage_mots(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %d\n",res);
/****************************************************************************
POINTEURS VERS NULL
****************************************************************************/
printf("Comptage des pointeurs vers NULL\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res=comptage_nil(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %d\n",res);
/****************************************************************************
CREATION ET DESTRUCTION DE LA LISTE DES MOTS
****************************************************************************/
printf("Creation et destruction de la liste des mots\t\t: En cours ...");
fflush(stdout);
temps(&start);
mots=liste_mots(t);
while(mots->taille!=0){
char * tmp=supprimer_debut(mots);
free(tmp);
}
free(mots);
temps(&end);
afficher_res(start,end);
/****************************************************************************
HAUTEUR
****************************************************************************/
printf("Calcul de la hauteur \t\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res=hauteur(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %d\n",res);
/****************************************************************************
EQUILIBRAGE
****************************************************************************/
printf("Equilibrage du trie\t\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
t=equilibrer(t);
temps(&end);
afficher_res(start,end);
/****************************************************************************
RECALCUL HAUTEUR
****************************************************************************/
printf("Recalcul de la hauteur \t\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res=hauteur(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %d\n",res);
/****************************************************************************
PROFONDEUR MOYENNE
****************************************************************************/
printf("Profondeur Moyenne\t\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res_d=profondeur_moyenne(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %f\n",res_d);
/****************************************************************************
CONVERSION VERS BRIANDAIS
****************************************************************************/
printf("Conversion vers arbre de la briandais\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
br=conversion(t);
temps(&end);
afficher_res(start,end);
destroy_briandais(&br);
/****************************************************************************
INSERTION D'UN MOT INEXISTANT
****************************************************************************/
printf("Insertion d'un mot inexistant(anticonstitutionnellement): En cours ...");
fflush(stdout);
temps(&start);
t=ajouter_trie_hybride("anticonstitutionnellement",t);
temps(&end);
afficher_res(start,end);
/****************************************************************************
INSERTION D'UN MOT INEXISTANT
****************************************************************************/
printf("Usage memoire (en octets)\t\t\t\t: En cours ...");
fflush(stdout);
temps(&start);
res=usage_memoire(t);
temps(&end);
afficher_res(start,end);
printf("\t\t\t\t\t\t\t %d\n",res);
free_trie_hybride(t);
return EXIT_SUCCESS;
}
int main()
{
int choix;
Liste *liste = NULL; // Liste des variables
do
{
printf("\n______________________________\n"
"1 - Utilisation de la mémoire\n"
"2 - Ajouter une variable\n"
"3 - Afficher une variable\n"
"4 - Supprimer une variable\n"
"Autre - Quitter\n"
"Choix : ");
scanf("%d", &choix);
printf("------------------------------\n\n");
switch(choix)
{
case 1: // Utilisation de la mémoire
printf("Mémoire utilisée : %d octet\n", mem.fin + 1);
break;
case 2: // Ajout d'une variable
{
// nom
char nom[100];
printf("Nom de la variable : ");
scanf("%s", nom);
if(recherche_variable(liste, nom))
printf("%s existe déja\n", nom);
else
{
// taille
int taille;
printf("Taille : ");
scanf("%d", &taille);
// type
int typeNum = 0;
printf("Type : \n"
"0 - INT\n"
"1 - CHAR\n"
"2 - FLOAT\n"
"3 - SHORT\n"
"4 - LONG\n"
"5 - DOUBLE\n");
scanf("%d", &typeNum);
// allocation
Variable var = allouer(nom, taille, (Type) typeNum);
// valeur
printf("Valeurs : \n");
lire_valeur(var);
// stockage dans la liste
liste_ajout(&liste, var);
}
break;
}
case 3: // Affichage d'une variable
{
char nom[100];
printf("Entrez le nom de la variable : ");
scanf("%s", nom);
Variable *var = recherche_variable(liste, nom);
if(var)
{
printf("Adresse : %d\n"
"Type : %s\n"
"Valeur : \n",
var->adrs, type_a_chaine(var->type));
afficher_val(*var);
printf("\n");
printf("Taille : %d\n", var->size);
}
else printf("\"%s\" n'existe pas\n", nom);
break;
}
case 4: // Supression d'une variable
{
char nom[100];
printf("Entrez le nom de la variable : ");
scanf("%s", nom);
Variable *recherche = recherche_variable(liste, nom);
if(recherche)
{
supprimer(*recherche);
liste_supprimer(&liste, nom);
}
else
printf("%s n'existe pas\n", nom);
}
}
} while( 1 <= choix && choix <= 4);
return 0;
}
