Prob d'exception c++

Fermé
Havoc - 7 mars 2010 à 17:00
Bonjour,

Ce code est immense afin de pouvoir travailler sur tout le code .Alors voici le problème : ce programme lorsque l'on choisi 1. On doit donner l'ordre du carre magique seul problème si il est pair cela doit retourner l'exception mais la ca ne marche pas c'est dans le switch choix 1 .Merci de nous aider s'il vous plait .

Voila le code :

/****************************************************************************/
// ROLE DU PROGRAMME | Version 4+5 du Carre //
//------------------------|---------------------------------------------------//
// FICHIER SOURCE | /lng9503a/Version4.C //
//------------------------|---------------------------------------------------//
// LANGAGE | C++ //
//------------------------|---------------------------------------------------//
// UTILISATEUR | lng9503a //
//------------------------|---------------------------------------------------//
// AUTEUR(S) | Lannes-Lacrouts Guillaume , Heurtaux Gaëtan //
// | //
//------------------------|---------------------------------------------------//
// DATE CREATION | 02/03/2010 //
// DATE MISE A JOUR | 04/02/2010 //
//****************************************************************************//



#include <iostream>
#include <string>

using namespace std;

//Définition du carré
const int TAILLE = 100 ;
typedef int Carre[TAILLE][TAILLE] ;

//Definition d'un tableau d'entiers

typedef int TabEntiers[(TAILLE*2)+2][(TAILLE*2)+2] ;

//initialise une matrice carrée d’entiers d’ordre n à zéro
//lève l’exception "ORDRE INCORRECT" si n ne vérifie pas 0 ≤ n ≤ TAILLE
void initialiserCarre ( Carre carre , const int n ) throw (string)
{
int i,j ;

if ( n<0 || n > TAILLE )
{
throw string("ORDRE INCORRECT");

}

for ( int i=0; i < n ; i++ )
{
for ( int j=0 ; j < n ; j++ )
{
carre[i][j] = 0 ;
}
}
}

//lit une matrice carrée d’ordre n d’entiers désignée par carré à partir
//de valeurs saisies au clavier
//lève l’exception "ORDRE INCORRECT" si n ne vérifie pas 0 ≤ n ≤ TAILLE

void lireCarre ( Carre carre , const int n ) throw (string)
{

if ( n<0 || n > TAILLE )
{
throw string("ORDRE INCORRECT");

}

for ( int j=0 ; j < n ; j++ )
{
for ( int i=0 ; i < n ; i++ )
{
cin >>carre[i][j] ;
}
}
}

//affiche une matrice carrée d’ordre n d’entiers désignée par carré
//lève l’exception "ORDRE INCORRECT" si n ne vérifie pas 0 ≤ n ≤ TAILLE
void ecrireCarre ( const Carre carre , const int n ) throw (string)
{
if ( n<0 || n > TAILLE )
{
throw string("ORDRE INCORRECT");

}

for ( int j=0 ; j < n ; j++ )
{
for ( int i=0 ; i < n ; i++ )
{
cout <<carre[i][j];
cout <<" ";
}
cout <<" "<< endl;
}
}

//détermine si l’entier i est un nombre impair
bool estImpair (const int i)
{
if ( (i%2) == 0)
{
return false;
}
else
{
return true;
}
}

//calcule et renvoie la somme d’une ligne i d’une matrice carrée
//d’entiers d’ordre n désignée par carré
//lève l’exception "LIGNE INVALIDE" si i ne vérifie pas 0 ≤ i ≤ n-1
// lève l’exception "ORDRE INCORRECT" si n ne vérifie pas 0 ≤ n ≤ TAILLE
int sommeLigne ( const Carre carre , const int n , const int i) throw (string)
{

int som=0;

if ( n<0 || n > TAILLE )
{
throw string("ORDRE INCORRECT");

}
if ( i<0 || i > (n -1) )
{
throw string("LIGNE INVALIDE");

}

for (int j=0 ; j < n ; j++)
{
som = som + carre[i][j];
}
return som;
}


// calcule et renvoie la somme d’une colonne j d’une matrice carrée
// d’entiers d’ordre n désignée par carré
// lève l’exception "COLONNE INVALIDE" si j ne vérifie pas 0 ≤ j ≤ n-1
// lève l’exception "ORDRE INCORRECT" si n ne vérifie pas 0 ≤ n ≤ TAILLE
int sommeColonne ( const Carre carre , const int n , const int j) throw (string)
{

int som=0 ;

if ( n<0 || n > TAILLE )
{
throw string("ORDRE INCORRECT");


}
if ( j<0 || j > (n -1) )
{
throw string("COLONNE INVALIDE");

}
for ( int i=0; i < n ; i++ )
{
som = som + carre [j][i] ;
}
return (som) ;
}

//calcule et renvoie la somme de la première diagonale d’une matrice carrée
//d’entiers d’ordre n désignée par carré
//lève l’exception "ORDRE INCORRECT" si n ne vérifie pas 0 ≤ n ≤ TAILLE

int somme1erediagonale ( const Carre carre, const int n ) throw (string)
{
int som=0 ;
if ( n<0 || n > TAILLE )
{
throw string("ORDRE INCORRECT");


}

for ( int i=0 ; i < n ; i++ )
{
som = som + carre[i][i] ;
}
return som;
}

// calcule et renvoie la somme de la deuxième diagonale d’une matrice carrée
// d’entiers d’ordre n désignée par carré
// lève l’exception "ORDRE INCORRECT" si n ne vérifie pas 0 ≤ n ≤ TAILLE

int somme2emediagonale(const Carre carre, const int n) throw (string)
{
int som=0 ;
int i,j;
if ( n<0 || n > TAILLE )
{
throw string("ORDRE INCORRECT");


}

for ( i=0 , j=n-1 ; i < n ; i++ , j-- )

{
som = som + carre[i][j] ;
}

return som;
}

//détermine si tous les éléments d’un tableau d’entiers tab de n éléments
//sont égaux à la valeur val
//lève l’exception "LONGUEUR INCORRECTE" si n ne vérifie pas 0 ≤ n ≤ NB_SOMMES
bool ElementsEgaux ( const Carre carre , const int n, const int val) throw (string)

{
int c=0 ; // Nombres d'éléments égaux dans le carré


for ( int i=0 ; i < n ; i++)
{
for (int j=0; j< n ; j++)
{

if ( carre[i][j] == val )
{
c++;
}
}
}

if ( c == (n*n ))
{
return true ;
}

return false ;
}

//détermine si une matrice carrée d’ordre n désignée par carré est magique
//lève l’exception "ORDRE INCORRECT" si n ne vérifie pas 0 ≤ n ≤ TAILLE
//lève l’exception "ORDRE PAIR" si n est pair
bool estCarreMagique (const Carre carre, const int n) throw (string)
{
int somme2,som ;
int i=0;
if ( n<0 || n > TAILLE )
{
throw string("ORDRE INCORRECT");


}
if ( ! estImpair(n) )
{
throw string("ORDRE PAIR");

}

//Recuperation du résultat de la fonction sommeLigne
som = sommeLigne(carre,n,i);

for( int i=0; i< n; i++ )
{
if( sommeLigne(carre,n,i)!= som )
return false;
}

for( int i=0; i < n; i++ )
{
if( sommeColonne(carre,n,i)!= som )
return false;
}
//Recuperation du résultat de la fonction somme1erediagonale
somme2 = somme1erediagonale(carre,n);

if( somme1erediagonale(carre,n)!=som || somme2emediagonale(carre,n)!=som)
return false;

return true;
}


// construit un carré magique d’ordre n
// lève l’exception "ORDRE PAIR" si n est pair
// lève l’exception "ORDRE INCORRECT" si n ne vérifie pas 0 <= n <= TAILLE
void construireCarremagique ( Carre carre , const int n ) throw (string)
{
int j=0;
int i,c ;

if ( n<0 || n > TAILLE )
{
throw string("ORDRE INCORRECT");


}
if ( ! estImpair(n))
{
throw string("ORDRE PAIR");

}


//Initialisation : positionement du 1 dans le milieu de la ligne superieure
i = ((n-1) / 2 );
carre[i][j]=1;
c=2;

//Limite de placement des chiffres ( 2 Ã n*n)
while ( c < ((n*n)+1) )
{
i++ ;
j-- ;
//Condition de débordement de la ligne hors du carré
if (i > n-1)
i=0;
//Condition de débordement de la colonne hors du carré
if (j < 0)
j= n-1;
//Case déjà occupée donc positionnement sous la case précédente
if (carre[i][j] != 0 )
{
j++;
if (j > (n-1))
j= 0;
j++;
if (j > (n-1))
j= 0;
i--;
if (i < 0)
i= n-1;
}


//écriture du chiffre
carre[i][j]= c ;
c++;
}


}



//Menu gérant la saisie d'une matrice carrée plus sa vérification , et le calcul d'un carré magique et son affichage


int main ()
{
int choix ,n ; //Déclaration du choix et de l'ordre
bool a,b; //Déclaration des booleens pour les fonction estImpair et estCarremagique
Carre carre; //Déclaration du carré de type Carré
TabEntiers tab; // Tableau d'entiers


cout <<"Que voulez vous faire?"<<endl;
cout<<" "<< endl;
cout<<"1.Saisir une matrice carree et determiner si elle correspond a un carre magique"<<endl;
cout<<"2.Calculer et afficher le carre magique d'une matrice carree d'ordre n"<<endl;
cout<<"3.Quitter l'application"<<endl;
cout<<"Votre choix: "<<endl;
cin >>choix;


//Boucle gérant la répétion du menu ainsi que de ses choix
while ( choix != 3)
{

//Gere les choix 1,2 et 3
switch (choix)
{
case 1 : cout<<"Tapez l'ordre de votre carré: "<<flush;
cin>>n;
try
{
if (estImpair(n)==true)
{
initialiserCarre ( carre , n ) ;
lireCarre (carre ,n);
if (ElementsEgaux (carre,n,carre[0][0])==false)
{
ecrireCarre ( carre , n );
b=estCarreMagique(carre,n);

if ( b== false )
{
cout<<"Le carré n'est pas magique"<<endl;
break;
}
else
{
cout<<"Le carré est magique"<<endl;
break;

}
}
}
else
{
break;
}
cout <<"Que voulez vous faire?"<<endl;
cout<<" "<< endl;
cout<<"1.Saisir une matrice carree et determiner si elle correspond a un carre magique"<<endl;
cout<<"2.Calculer et afficher le carre magique d'une matrice carree d'ordre n"<<endl;
cout<<"3.Quitter l'application"<<endl;
cout<<"Votre choix: "<<endl;
cin >>choix;
}


catch (const string &message)
{
cerr << message << endl ;
return(1);
}


case 2 : cout<<"Tapez l'ordre de votre carré: "<<endl;
cin >>n;

try{
estImpair(n);
initialiserCarre ( carre , n ) ;
construireCarremagique ( carre , n );
ecrireCarre ( carre, n );
break;
}
catch (const string &message)
{
cerr << message << endl;
}

case 3 : break;


}

cout <<"Que voulez vous faire?"<<endl;
cout<<" "<< endl;
cout<<"1.Saisir une matrice carree et determiner si elle correspond a un carre magique"<<endl;
cout<<"2.Calculer et afficher le carre magique d'une matrice carree d'ordre n"<<endl;
cout<<"3.Quitter l'application"<<endl;
cout<<"Votre choix: "<<endl;
cin >>choix;
}
}