SYSTEM EXPERT

#include <iostream.h>
#include <conio.h> //getch 

struct liste {                  //déclaration nécissaire
		 char el;
		 liste * next;
 };

struct fait {
		 char el;
		 char test;
		 fait * next;
 };

struct regle {
		liste * condition;
		liste * resultat;
		char testr;
		regle * suivant;
 };

//##############################################################

fait * Creation_Base_Fait (fait * F){
	int k;
	
	  F = new fait;
	  cout<<"\nDonner une base fait : ";
	  cin>> F->el;
	  F->test = '#';
	  F->next = NULL;

	  fait * p = F;

	 cout<<"\nContinier ... 0/1 : ";  cin>> k;
	  while (k != 0 ) {
			  fait * q = new fait;
			  cout<<"\nDonner une base fait : ";
			  cin>> q->el;
			  q->test = '#';
			  q->next = NULL;
			  p->next = q;
			  p = q;

			cout<<"\nContinier ... 0/1 : ";  cin>> k;
	 }
	return F;
}

//##############################################################

liste * creation (int n){
 liste * tete = new liste;
 cin>> tete->el;
 tete->next = NULL;
 liste * q = tete;

 for (int i = 2; i<=n; i++){
	  cout<<"--- ^ ---\n";
	  liste * p = new liste;
	  cin>> p->el;
	  p->next = NULL;
	  q->next = p;
	  q = p;
	}
	return tete;
}

//------------------------------------------------

regle * Creation_Base_Regle (regle * Rr){
		 int n1,n2; int k;
		Rr = new regle;

		cout<<"\nDonner le nombre de condition : "; cin >> n1;
		Rr->condition = creation (n1);
		cout<<"\nDonner le nombre de resultat : "; cin >> n2;
		Rr->resultat = creation (n2);
		Rr->testr = '*';
		Rr->suivant = NULL;

		 cout<<"\nContinier ... 0/1 : ";  cin>> k;
		 regle * p = Rr;
	while (k != 0 ) {
			regle * q = new regle;

		cout<<"\nDonner le nombre de condition : "; cin >> n1;
		q->condition = creation (n1);
		cout<<"\nDonner le nombre de resultat : "; cin >> n2;
		q->resultat = creation (n2);
		q->testr = '*';
		q->suivant = NULL;
        p->suivant = q;
		p = q;

		cout<<"\nContinier ... 0/1 : ";  cin>> k;
  }
return Rr;
}

//##############################################################


void Ajoute_Regle(regle * &R) {
	int n1,n2;
	regle * nouveau = new regle;

		cout<<"\nDonner le nombre de condition : "; cin >> n1;
		nouveau->condition = creation (n1);

		cout<<"\nDonner le nombre de resultat : "; cin >> n1;
		nouveau->resultat = creation (n1);

		nouveau->testr = '*';

		nouveau->suivant = NULL;

	regle * p = R;

	while (p->suivant != NULL)
		 p = p->suivant;

	 p->suivant = nouveau;


}

//------------------------------------------------

void Ajoute_Fait (fait * &F,char el, char x){
	  fait * nouveau = new fait;
	  nouveau->el=el;
	  nouveau->test = x;
	  nouveau->next = NULL;

	  fait * p =F;
	while (p->next != NULL)
		 p = p->next;

	 p->next = nouveau;
}

//######################################################

void Afficher_Base_Conn (fait * F, regle * R){
		 fait * ff = F;
	  while (ff != NULL){
				cout<< ff->el<<"\n";
			 ff=ff->next;
	  }

	  regle * rr = R;
	  while (rr != NULL){
			  liste * p = rr->resultat;
				  while (p != NULL){
						cout<< p->el<<"\n";
					 p = p->next;
				  }

	  rr=rr->suivant;
	  }
}

//######################################################

int nombre_liste (liste * li){    //nombre d'élément d'une liste
	  int cpt = 0;
	  for (liste * p = li; p != NULL; p = p->next)
			 cpt ++;

	return cpt;
}

//------------------------------------------------------

int egual  (liste * regcon , liste * L2){    //test égalité de deux listes
		 int cpt = 0;

	 for (liste *p2 = L2; p2!= NULL; p2=p2->next)
	    for (liste *reg = regcon; reg!= NULL; reg=reg->next)
	             if (p2->el == reg->el)
                      cpt ++;
                      
	if  ((nombre_liste (L2) == cpt))
	  return 1;
	else
	  return 0;
}

//------------------------------------------------------------------

int Moteur_Inference (liste * L ,fait * &F, regle * &R){
	  regle * r = R;  int n1;

	  cout<<"\nDonner le nombre n : "; cin >> n1;
	  L = creation (n1);

	while (r != NULL) {
		if (r->testr == '*')
			  if ((nombre_liste (L)) == (nombre_liste (r->condition)))
				  if(egual(r->condition, L ) == 1) {
						  r->testr = '#';
						  for (liste * p = r->resultat; p != NULL; p = p->next)
							  Ajoute_Fait (F,p->el , '*');

							  return 0;
				}
	r = r->suivant;
	}
	return 0;
}

//###################################################################

void Afficher_Resultat (fait * M) {  //affichage des résultat éxécution de moteur inference 
	  fait * p = M;

	  while (p != NULL){
		  if (p->test == '*')
				 cout<<"\nResultat est : "<< p->el;

		p = p->next;
	 }
}


//#########################################################################
//#########################################################################
//#########################################################################

void afficherMenu(void)  //affichage de menu
{

			cout<<"       ---------------------------------------  \n";
			cout<<"       | 1- saisir les faits .               |  \n";
			cout<<"       | 2- Saisir les regles .              |  \n";			
			cout<<"       | 3- Ajouter une regle.               |  \n";
			cout<<"       | 4- Ajouter un fait.                 |  \n";
			cout<<"       | 5- Affichager base de connaissance. |  \n";
			cout<<"       | 6- Moteur d inference.              |  \n";
			cout<<"       | 7- affichage du resultats.          |  \n";
			cout<<"       | 0- Quiter.                          |  \n";
			cout<<"       ---------------------------------------  \n ";
			cout<<"           Realiser Par MISSOUM Abdelkader      \n";
			cout<<"                  en 18/01/2008                 \n";
			cout<<"            E-mail: kader.missoum@yahoo.fr      \n";
}

int main(){

  regle *RRR = NULL; regle*R; 
  fait *FFF = NULL ; fait *F;
  liste * LL; char K;
  int nn;
  char choix;

  do {

afficherMenu();
 choix = getch();
	 switch ( choix )
	 {
		case '1':
  cout<<"\n-----------------------------------------------------\n";
  cout<<"\n\tCHARGEMENT BASE DE FAIT\n ";
		  FFF = Creation_Base_Fait(F);
		  getch();
		break;
		
		case '2':
  cout<<"\n-----------------------------------------------------\n";
  cout<<"\n\tCHARGEMENT BASE DE REGLE\n ";
          RRR=Creation_Base_Regle(R);
		  getch();
        break;

		case '3':
  cout<<"\n-----------------------------------------------------\n";
  cout<<"\n\tAJOUTE UNE REGLE\n ";
		  Ajoute_Regle(RRR);
		  getch();
		break;

		case '4':
  cout<<"\n-----------------------------------------------------\n";
  cout<<"\n\tAJOUTE UN FAIT\n ";
		cout<< "\nDonner une base de fait : "; cin >> K;
		  Ajoute_Fait(FFF,K, '#');
		  getch();
		break;

		case '5':
  cout<<"\n-----------------------------------------------------\n";
  cout<<"\n\tAFFICHAGE BASE DE CONNAISSANCE\n ";
             cout<<"\nLa base de connaissance est : \n";
			 Afficher_Base_Conn ( FFF, RRR);
		  getch();
		break;

		case '6':
  cout<<"\n-----------------------------------------------------\n";
  cout<<"\n\tMOTEUR D'INFERENCE \n ";
			  Moteur_Inference (LL,FFF , RRR);
		  getch();
		break;

		case '7':
  cout<<"\n-----------------------------------------------------\n";
  cout<<"\n\tRESULTAT \n ";           
			 Afficher_Resultat (FFF) ;
		  getch();
		break;
	 }
  }
  while ( choix != '0' );

cout<<"\n         ----- LE PROGRAMME TERMINE -----";


cin>>nn;
return 0;
}