Delucidazioni sul costrutto switch case

di il
9 risposte

Delucidazioni sul costrutto switch case

Salve ragazzi,
vorrei avere dei chiarimenti riguardo il costrutto "SWITCH CASE", ho già cercato su internet delle info a riguardo, ma mi sono rimasti comunque alcuni dubbi, tipo: è possibile inserire nell'espressione dello switch una variabile di tipo string come nel seguente esempio?
string triangolo;
switch (triangolo){
	case "equilatero": istruzione;
			   break;
	case "isoscele": istruzione;
			   break;
	case "scaleno": istruzione;
			   break;
}
Ho già provato a fare in questo modo, ma il compilatore mi dà errore di sintassi.

Se è possibile comunque fare ciò, qual è la sintassi giusta? Oppure questo costrutto accetta solo variabili di tipo int o char?

9 Risposte

  • Re: Delucidazioni sul costrutto switch case

    L'ultima che hai detto ...
  • Re: Delucidazioni sul costrutto switch case

    Ah peccato ! Comunque grazie Oregon ciao


    Inviato dal mio iPad utilizzando Tapatalk
  • Re: Delucidazioni sul costrutto switch case

    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; 		
    }
    
    
    
  • Re: Delucidazioni sul costrutto switch case

    Hai tenuto conto delle approssimazioni ?

    Tu confronti con un valore reale (PIGRECO/2) ma non è detto che dal calcolo tu ottenga *esattamente* quel valore e il controllo == fallisce.
  • Re: Delucidazioni sul costrutto switch case

    Si si ho tenuto conto delle approssimazioni, il problema è che ho provato a mettere sia
    gamma<=(PI_GRECO/2) che gamma>=(PI_GRECO/2), il risultato è sempre lo stesso, quindi ho riportato tutto a gamma==(PI_GRECO/2)
  • Re: Delucidazioni sul costrutto switch case

    Puoi visualizzare il valore di gamma prima della if ?
  • Re: Delucidazioni sul costrutto switch case

    Come no, appena stacco da lavoro faccio il debug e t faccio sapere quanto vale gamma quando dovrebbe essere 90°
  • Re: Delucidazioni sul costrutto switch case

    Ciao Oregon, allora ho fatto come mi hai chiesto e facendo il debug e mettendo un breakpoint prima dell'if, il valore di gamma è 1,57079649. Oggi mi hai fatto venire il dubbio, ho convertito in Excel questo valore in radianti in gradi, ottenendo questo risultato: 90,00000935°. Siccome c'ho già pensato l'altro giorno a questo, ho provato a mettere come t'ho già scritto sia gamma<=pigreco/2 che gamma>=pigreco/2, adesso non mi rimane che mettere al posto di gamma==pigreco/2 una condizione più precisa, tipo: fare la differenza tra pigreco/2 meno il valore di gamma, se il risultato è minore o uguale a 0,000001 il triangolo è rettangolo; oppure posso (secondo me è il modo più veloce e semplice) anziché calcolare per sottrazione gamma, calcolarmela trigonometricamente, visto che con alpha e beta non ho avuto problemi. Secondo te quale opzione è migliore?
  • Re: Delucidazioni sul costrutto switch case

    Ho fatto come ho detto ed ho risolto, cmq era come prevedevi Oregon....grazie ancora
    Ps: cmq c'è da impazzire...
Devi accedere o registrarti per scrivere nel forum
9 risposte