08/04/10 13:50
XBarboX
Salve,
sto studiando la programmazione ad oggetti in c++.
Ho fatto questa semplice classe che gestisce le quattro operazioni fondamentali:
MAIN.CPP
#include <iostream>
#include "calcolatrice.h"
using namespace std;
int main(){
Calc c;
c.x = 10;
c.y = 20;
cout<<c.somma()<<endl;
cout<<c.sottrazione()<<endl;
cout<<c.moltiplicazione()<<endl;
cout<<c.divisione()<<endl;
system("pause");
return 0;
}
CALCOLATRICE.H
class Calc{
public:
float x;
float y;
float somma();
float sottrazione();
float moltiplicazione();
float divisione();
Calc(){
x = 0;
y = 0;
}
};
CALOCOLATRICE.CPP
#include "calcolatrice.h"
float Calc::somma(){
return Calc::x + Calc::y;
}
float Calc::sottrazione(){
return Calc::x - Calc::y;
}
float Calc::moltiplicazione(){
return Calc::x * Calc::y;
}
float Calc::divisione(){
return Calc::x / Calc::y;
}
Questo sorgente funziona, ma voglio chiedervi tre cose:
1)Ho fatto qualche errore di "bella programmazione"
2)Il distruttore é necessario?
3)Come posso evitare di scrivere ogni volta "Calc::x"? Ovvero é possibile scrivere solo "X" al posto di "Calc::x" ??
Grazie mille
Ultima modifica effettuata da XBarboX 08/04/10 13:56
aaa
08/04/10 16:36
Xaratroom
Postato originariamente da HeDo:
puoi evitare di usare l'operatore di risoluzione di scopo quando accedi alle variabili membro, basta il nome o this->variabile.
Forse è stata una svista ma si chiama risolutore di scope (ossia ambito o contesto).
Postato originariamente da HeDo:
per il resto è una cosa talmente minimale che più di così non si può dire
A parte il controllo su denominatore assente in divisione() (nel quale inserirei un throw) io eviterei (come ha detto HeDo) l'accesso diretto agli attributi, a favore di setter e getter.
Poi inserirei un'altro costruttore:
Calc(float x, float y) ...
e utilizzerei una lista di inizializzazione per assegnare i valori agli attributi.
PS: forse rompo un po' ma il nome della classe lo scriverei per intero...
Ultima modifica effettuata da Xaratroom 08/04/10 16:38
aaa
08/04/10 20:46
TheKaneB
Una calcolatrice, di per se, ha un accumulatore che contiene l'ultima risposta o answer, abbreviato ANS.
Poi ha una memoria M.
una serie di operazioni aritmetiche e un Input.
Tutte le operazioni avvengono tra ANS e Input.
quindi io metterei nella classe non x,y, ma ANS ed M. E come unico operando esplicito di somma, sottrazione, prodotto e divisione userei un Input (il secondo operando è ANS).
Fatta in questo modo, invece, la calcolatrice non ha senso, diventa solo un contenitore di metodi che, a questo punto, è meglio dichiarare come static e passargli ogni volta i parametri x,y visto che non ha senso usarli come variabili interne, visto che sono scorrelate con un eventuale "stato interno" della calcolatrice :-)
aaa
09/04/10 6:09
Xaratroom
Diciamo che (per essere pignoli) se avesse scritto il nome della classe per intero non ci sarebbero stati problemi di comprensione:
class Calcolo
{
public:
float somma ();
float prodotto ();
....
}
class Calcolatrice
{
private:
float _ans;
public:
bool operazione (char operando, float valore);
float getRisultato ();
...
}
class Calciatore
{
public:
float somma () { return (float)rand(); };
float prodotto () { return (float)rand(); };
float divisione () { while (1); };
...
}
EDIT: Ho quotato perchè non mi vedeva il bb code
Ultima modifica effettuata da Xaratroom 09/04/10 6:12
aaa
09/04/10 6:55
XBarboX
Grazie a tutti.
Volevo chiedere ancora una cosa riguardo i costruttori/distruttori:
I costruttori sono obbligatori? Perchè non sempre si ha bisogno di inizializzare le variabili.
E poi il distruttore credo che serva a niente, che te ne fai di dare un valore alle variabili quando finisce il programma?
aaa
