[C++] espressioni logiche

[riemann_01]

[Modificato]

Buongiorno a tutti! Questo e' il mio primo post! Mi chiamo Francesco ed ho quattordici anni.

Da qualche giorno ho iniziato a studiare il linguaggio di programmazione C++ e sto scoprendo lentamente un mondo nuovo per me affascinante.

Durante lo svolgimento di alcuni esercizi di riepilogo a fine capitolo, contenuti nel libro che ho acquistato, ho incontrato le prime difficolta'.

Il programma che segue, da me scritto, effettua una semplice conversione tra scale di temperatura.

// temp.cc - temperature converter, integer value

#include <iostream>
using namespace std;

void convert(int temp, char c)
{
	int x;
	
	switch(c) {
		case 'f':
			x = static_cast<int>(5.0  / 9.0 * (temp - 32.0));
			cout << "Tc = " << x << endl;
			break;
		case 'c':
			x = static_cast<int>(9.0 / 5.0 * temp + 32.0); 
			cout << "Tf = " << x << endl;
			break;
		default:
			cout << "an error occured!";
	}
}

int main()
{
	int t;
	char ch;
	
	cout << "Temperature converter - °F ~ °C\n";
	do {
		cout << "Scale? (c/f): ";
		cin >> ch;
	} while(ch != 'f' && ch != 'c');
	cout << "Valore: ";
	cin >> t;
	convert(t,ch);
}

Per quale motivo l'espressione di controllo dell'istruzione do while funziona esclusivamente con un AND?

Ragionando sulla condizione questa non dovrebbe essere del tipo "finquando il carattere digitato non e' uguale a f o c riproponi l'input?".
Se cosi fosse perche' non puo' essere codificata con un OR? (loop!)

do {
   cout << "Scala? (c/f): ";
   cin >> ch;
} while(ch != 'f' || ch != 'c');

Chi puo' darmi delucidazioni a riguardo?

[scorpion89]

Molto semplicemente xkè le condizioni sono invertite.
Cioè il do... while si può tradurre in un esci dal ciclo quando ch=='f' or ch=='c'
ma visto ke la condizione da scrivere è quella opposta viene fuori la condizione negata e
quindi
ch!='f' && ch!='c'

Scusa se mi sono spiegato male!!

Ciao

[riemann_01]

La tua spiegazione e' leggermente oscura! LOL

Credo comunque di aver capito l'errore.
Ho analizzato in modo piu' approfondito la questione.

La condizione deve essere interpretata come: "esegui queste istruzioni finquando il carattere digitato e' diverso da c ed f".

In ogni caso, grazie per la risposta!

[andbin]

Originariamente inviato da riemann_01

La condizione deve essere interpretata come: "esegui queste istruzioni finquando il carattere digitato e' diverso da c ed f".

Esatto, la condizione nel while deve essere vera affinché il ciclo do-while si ripeta.

[scorpion89]

scusa ma l'italiano nn è il mio forte


Ciao

[mr_hyde]

Riemann: visto che sei agli inizi mi permetto di darti un piccolo consiglio.
Nella tua funzione "convert" hai usato il passaggio di parametri con il reference (& dopo il tipo del parametro).
Pero' la tua funzione NON modifica i due parametri. In questo caso NON devi quindi usare & per il passaggio di parametri.

"&" va usato solo quando i parametri devono essere modifcati e restituiti modificati al chiamante.

Ad esempio:

void funzione_che_cambia(int& i)
{
i = 3;
}

void funzione_che_non_cambia(int i)
{
i = 3;
}

int main()
{
int a = 1;
std::cout << "Inizio con il valore " << a << std::endl;

// ora chiamo la funzione che NON cambia il valore
funzione_che_non_cambia(a);

std::cout << "Dopo la chiamata ho il valore " << a << std::endl;

// ora chiamo la funzione che CAMBIA il valore
funzione_che_cambia(a);

std::cout << "Dopo la chiamata ho il valore " << a << std::endl;

return 0;
}

La differenza e' molto importante e lo diventera' ancora di piu' quando inizierai a scrivere classi e metodi e le cose si complicheranno un pochino...

Se queste cose le sai gia'... allora chiedo scusa!

Ciao,
Mr Hyde

[riemann_01]

Grazie per il consiglio mr_hyde!

Conosco la differenza fra call-by-value e call-by-reference.

Scrivendo la procedura convert ho pensato che si potesse operare una forma "banale" di ottimizzazione evitando l'uso di due variabili locali.

Utilizzare questo metodo viola, in qualche modo, i concetti di programmazione modulare (procedurale)? Oppure e' un semplice "errore" semantico?

[mr_hyde]

Originariamente inviato da riemann_01

Grazie per il consiglio mr_hyde!

Conosco la differenza fra call-by-value e call-by-reference.

Scrivendo la procedura convert ho pensato che si potesse operare una forma "banale" di ottimizzazione evitando l'uso di due variabili locali.

Utilizzare questo metodo viola, in qualche modo, i concetti di programmazione modulare (procedurale)? Oppure e' un semplice "errore" semantico?

Be', l'esempio e' un po' scarno per parlare di violazione di programmazione modulare...

Ad ogni modo e' vero, qualche volta capita di passare reference per motivi di ottimizzazione, ma generalmente si fa con oggetti "grossi".
E comunque, un tempo, qualcuno diceva che invece che passare un reference, per motivi prestazionali, era meglio passare un puntatore all'oggetto, ma si parla di anni fa e nel frattempo i compilatori sono migliorati.

Se proprio vuoi usare i reference allora usa la forma con il const quando vuoi comunque impedire la modifica, ovvero:

int the_function(const int& nonLoCambio, float& loCambio)

Ciao,
Mr Hyde

[riemann_01]

Ti ringrazio per la disponibilita'.
A presto!

[sottovento]

Scusa la domanda: mi aspetterei che il tuo programma, nel caso 'f', ti stampi sempre zero. E' cosi?

High Flying
Sottovento

[riemann_01]

riemann@home:~$ ./convert
Temperature converter - °F ~ °C
Scala? (c/f): c
Valore: 26
Tf = 78
riemann@home:~$ ./convert
Temperature converter - °F ~ °C
Scala? (c/f): f
Valore: 100
Tc = 37

[sottovento]

Originariamente inviato da riemann_01

riemann@home:~$ ./convert
Temperature converter - °F ~ °C
Scala? (c/f): c
Valore: 26
Tf = 78
riemann@home:~$ ./convert
Temperature converter - °F ~ °C
Scala? (c/f): f
Valore: 100
Tc = 37

Beh, la versione 2.0 sembra funzionare decisamente meglio. Evidentemente la 1.0 stampava sempre zero...

High Flying
Sottovento

[riemann_01]

Stampava zero poiche' in convert si utilizzava l'aritmetica di tipo intero.
5 / 9 * (temp - 32) = 0 * (temp - 32)