Volevo risolvere il problema con lo switch case, ma non riesco a cavare un ragno dal buco . Sto facendo un pgm che in base alla lunghezza dei lati inseriti dall'utente dà in output tutte le caratteristiche di tale triangolo. Sono arrivato ad un punto dove veramente non riesco a capire dove è il problema, perchè facendo il debug le variabili risultano corrette e credo che anche errori logici non ci siano. Il problema viene fuori quando inserisco dei dati che definiscono un triangolo rettangolo il cui lato a 90° è gamma, invece quando l'angolo a 90° è alpha o beta l'output è corretto.Ora vi pubblico l'intero codice:
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <math.h>
using namespace std;
//Dichiarazione della costante globale PI_GRECO
const float PI_GRECO = 3.1415926536;
/**********Prototipo della funzione SideTriangle***************************************************/
string TypeTriangle(float ab, float bc, float ac, bool &controlloTriangolo);
/*------------------------------------------------------------------------------------------------*/
/**********Prototipo della funzione AnglebySides***************************************************/
void AngleTriangle(float ab, float bc, float ac, float &alpha, float &beta, float &gamma);
/*------------------------------------------------------------------------------------------------*/
/**********Prototipo della funzione Degrees***************************************************/
float Degrees(float rad);
/*------------------------------------------------------------------------------------------------*/
/**********Prototipo della funzione AreaTriangle***************************************************/
float AreaTriangle(float ab, float bc, float alpha, float gamma);
/*------------------------------------------------------------------------------------------------*/
/**********Prototipo della funzione OrthocenterTriangle********************************************/
float OrthocenterTriangle(float ab, float bc, float ac, float alpha, float gamma);
int main(void) {
//Dichiarazione delle variabili
float ab, bc, ac, alpha, beta, gamma, area, ortocentro;
bool controlloTriangolo;
string misura, triangolo, typeAngle;
//Dati di input
do{
//Chiedo all'utente d'inserire l'unità di misura metrica dei lati
cout <<"Inserire l'unita' di misura metrica relativa ai lati (mm,cm,m,km): ";
cin >>misura;
}
while(misura!="mm" && misura!="cm" && misura!="m" && misura!="km");
//Chiedo all'utente di inserire le dimensioni dei tre lati di un triangolo
cout <<"\nInserire la misura del primo lato 'AB': ";
cin >>ab;
cout <<"Inserire la misura del secondo lato 'BC': ";
cin >>bc;
cout <<"Inserire la misura del terzo lato (base) 'AC': ";
cin >>ac;
cout <<endl;
//Elaborazione
/*La variabile triangolo assume il valore stringa della funzione Typetriangle, la quale controlla
se i dati inseriti dall'utente possono definire un triangolo, ed il suo tipo: equilatero, isoscele
o scaleno*/
triangolo = TypeTriangle(ab,bc,ac,controlloTriangolo);
/*Le seguenti condizioni decidono in base al tipo di triangolo ed alle misure inserite di ab, ac e bc
di prendere delle decisioni*/
if (controlloTriangolo == false)
cout <<triangolo <<endl <<endl;
else{
AngleTriangle(ab,bc,ac,alpha,beta,gamma);
if (triangolo=="equilatero" || triangolo=="isoscele" || triangolo=="scaleno")
if (alpha<(PI_GRECO/2) && beta<(PI_GRECO/2) && gamma<(PI_GRECO/2))
typeAngle = "acutangolo";
else
if (alpha==(PI_GRECO/2) || beta==(PI_GRECO/2) || gamma==(PI_GRECO/2))
typeAngle = "rettangolo";
//Dati di output
cout <<"Il triangolo e' di tipo " <<typeAngle <<" " <<triangolo <<" e ha le seguenti caratteristiche:\n";
cout <<"Angolo Alpha = " <<Degrees(alpha) <<(Degrees(alpha)==1 ? " grado" : " gradi") <<endl;
cout <<"Angolo Beta = " <<Degrees(beta) <<(Degrees(beta)==1 ? " grado" : " gradi") <<endl;
cout <<"Angolo Gamma = " <<Degrees(gamma) <<(Degrees(gamma)==1 ? " grado" : " gradi") <<endl;
cout <<"Perimetro = " <<ab+bc+ac <<misura <<endl;
cout <<"Area = " <<AreaTriangle(ab,bc,alpha,gamma) <<misura <<"^2" <<endl <<endl;
//Output relativo all'ortocentro del triangolo
cout <<"Punti notevoli del triangolo:\n";
if (triangolo == "equilatero"){
ortocentro = OrthocenterTriangle(ab, bc, ac, alpha, gamma);
cout <<"L'ortocentro si trova all'interno del triangolo e dista dal vertice B: ";
cout <<ortocentro <<misura <<endl <<endl;
}
if (triangolo == "isoscele" || triangolo == "scaleno")
if (typeAngle == "rettangolo")
if (alpha == (PI_GRECO / 2))
cout <<"L'ortocentro coincide col vertice A!" <<endl <<endl;
else
if (beta == (PI_GRECO / 2))
cout <<"L'ortocentro coincide col vertice B!" <<endl <<endl;
else
if (gamma == (PI_GRECO / 2))
cout <<"L'ortocentro coincide col vertice C!" <<endl <<endl;
}
fflush(stdin);//Formatta lo standard input del buffer di tastiera
getchar();//Immagazzina un carattere
return (0);
}
/**********Funzione--> definisce il tipo di triangolo in base alla lunghezza dei 3 lati***********/
string TypeTriangle(float ab, float bc, float ac, bool &controlloTriangolo){
//Dichiarazione ed inizializzazione delle variabili locali
float pow_ab, pow_ac, pow_bc;
string triangolo=" ";
//Elaborazione
controlloTriangolo = false;//Inizializzazione della variabile
/*Condizione che controlla se i dati inseriti dall'utente possono definire un triangolo generico*/
if (((ab<(ac+bc)) && (ac<(ab+bc)) && (bc<(ab+ac))) && ((ab>(ac-bc)) && (ac>(ab-bc)) && (bc>(ab-ac))))
controlloTriangolo = true;
if (controlloTriangolo == false)//Controlla se i dati inseriti possono definire un triangolo
triangolo = "I valori inseriti non definiscono un generico triangolo!\n\n";
else
if ((ab==ac) && (ac==bc))//Controlla se il triangolo è equilatero
triangolo = "equilatero";
else
if ((ab==ac && ac!=bc) || (ac==bc && bc!=ab) || (bc==ab && ab!=ac))//Controlla se il triangolo è isoscele
triangolo = "isoscele";
else{
pow_ab = pow(ab,2);
pow_ac = pow(ac,2);
pow_bc = pow(bc,2);
if ((pow_ab==(pow_ac+pow_bc)) || (pow_ac=(pow_ab+pow_bc)) || (pow_bc=(pow_ab+pow_ac)))//Controlla se il triangolo è scaleno
triangolo = "scaleno";
}
//Output della funzione
return triangolo;
}
/******Funzione--> calcola le caratteristiche dei triangoli usando le dimensioni dei 3 lati*******/
void AngleTriangle(float ab, float bc, float ac, float &alpha, float &beta, float &gamma){
//Elaborazione
//Teorema di Carnot che calcola l'angolo alpha
alpha = (pow(ac,2) + pow(ab,2) - pow(bc,2)) / (2 * ac * ab);//cos(alpha)
alpha = acos(alpha);//arcos(alpha)
//Teorema di Carnot che calcola l'angolo beta
beta = (pow(ab,2) + pow(bc,2) - pow(ac,2)) / (2 * ab * bc);//cos(beta)
beta = acos(beta);//arcos(beta)
//Per sottrazione calcolo l'angolo gamma
gamma = PI_GRECO - (alpha + beta);
}
/******Funzione--> trasforma gli angoli espressi in radianti in gradi*****************************/
float Degrees(float rad){
//Dichiarazione delle variabili locali
float gradi;
//Elaborazione
gradi = (180 * rad) / PI_GRECO;
//Output della funzione
return gradi;
}
/******Funzione--> calcola l'area di un qualsiasi triangolo***************************************/
float AreaTriangle(float ab, float bc, float alpha, float gamma){
//Dichiarazione delle variabili locali
float ah, bh, ch, area_1, area_2, area;
//Elaborazione
ah = cos(alpha) * ab;//Calcola la lunghezza della base di area_1
ch = cos(gamma) * bc;//Calcola la lunghezza della base di area_2
bh = sin(alpha) * ab;//Calcola l'altezza del triangolo
area_1 = (ah * bh) / 2;//Calcola l'area della prima porzione di triangolo
area_2 = (ch * bh) / 2;//Calcola l'area della seconda porzione di triangolo
area = area_1 + area_2;//Calcola l'area complessiva sommando le area delle 2 porzioni di triangolo
//Output della funzione
return area;
}
/******Funzione--> calcola l'ortocentro di un qualsiasi triangolo*********************************/
float OrthocenterTriangle(float ab, float bc, float ac, float alpha, float gamma){
//Dichiarazione delle variabili locali
float x, bh, ap, cm, bp, bm, alpha_1, gamma_1, alpha_2, gamma_2, phi, ad, ao, oh, bo;
//Elaborazione
if (bc==ac && ab!=ac){//Condizione in cui AB è il lato disuguale del triangolo isoscele e AC assume il valore di AB
x = ac;
ac = ab;
ab = x;
}
else
if (ab==ac && bc!=ac){//Condizione in cui BC è il lato disuguale del triangolo isoscele e AC assume il valore di BC
x = ac;
ac = bc;
bc = x;
}//Fine condizione per triangolo isoscele
else
if (ab>bc && ab>ac){//Condizione in cui AB è il lato maggiore del triangolo scaleno e AC assume il valore di AB
x = ac;
ac = ab;
ab = x;
}
else
if (bc>ab && bc>ac){//Condizione in cui BC è il lato maggiore del triangolo scaleno e AC assume il valore di BC
x = ac;
ac = bc;
bc = x;
}//Fine condizione per triangolo scaleno
//Sezione della fuzione che calcola l'ortocentro del triangolo
bh = ab * sin(alpha);
ap = ac * cos(alpha);
cm = ac * cos(gamma);
bp = ab - ap;
bm = bc - cm;
alpha_1 = asin(bm/ab);
gamma_1 = asin(bp/bc);
alpha_2 = alpha - alpha_1;
gamma_2 = gamma - gamma_1;
phi = PI_GRECO - (alpha_2 + gamma_2);
ad = ac / sin(phi);//diametro del cerchio che circoscrive il triangolo risultante dalle 3 altezze
ao = ad * sin(gamma_2);
oh = ao * sin(alpha_2);
bo = bh - oh;//Ortocentro: distanza del punto di intersezione delle 3 altezze rispetto al vertice B del triangolo
return bo;
}