Ehm...
Allora allora...ho messo insieme le informazioni sulle classi inventandomi un piccolissimo programma, soltanto che ci sono delle cose che non mi sono ancora chiare e così lo posto, chiedendo a Enzo se mi potrebbe correggere i milioni di errori che ho commesso...
Mi vergogno un po' dopo i sofisticati programmi di Eugenio a postare i miei banali dubbi...però siccome vorrei imparare...!!!
Temo di aver fatto confusione coi vettori e le loro dichiarazioni...Aspetto correzioni (e sgridate!)
# include
# include
# include
//andrebbe fatto
//un programma di questo tipo e non so come fare se non postandolo...
//promettete di non ridere per la mia incapacità!!
class data //domanda1: posso usare dei vettori come componenti della classe?
{
int dd[2];
int mm[2];
int yy[4];
}
data Chegiorno(data oggi) //temo di aver sbagliato qualcosa qui...
{
data domani;
data domani= oggi.dd[]+1; //non so bene come rendere questo, so che è sbagliato..
return domani;
};
int main()
{
data oggi,domani; //istanza della classe data
oggi.dd[]= 05;
oggi.mm[]= 11;
oggi.yy[]= 2006;
domani= Chegiorno(oggi);
std::cout << "la data di oggi è: " << //cosa scrivo qui?? << std::endl;
std::cout << "la data di domani è: " << //e qui??? << std::endl;
return 0;
}Fra
3 commenti:
Ciao, urra' per il secondo autore!
Ho messo qualche commento
qui a proposito delle classi. Qualunque cosa non chiara, chiedete!
A presto,
pietro
Niente sgridate (quelle all'esame!), ma -- al contrario -- un invito anche agli altri a buttarsi! (ovvero chiedere... e rispondere!)
Aggiungo alcuni commenti meno generali di quelli di Pietro (prendete quelli come riferimento!), e più specifici al presente caso di Epsilon Ursae Majoris.
A parte le "imperfezioni" della "prima volta", l'idea è buona. Ci sono solo 3 o 4 cose, essenzialmente, da notare nel codice che hai scritto.
1/ La prima, come diceva Pietro, è che non sono necessari i vettori: il C/C++ (tipicamente) non manipola cifre, ma valori.
2/ Un paio riguardano la definizione della funzione Chegiorno:
2a/ la riga
data domani;
dichiara (correttamente) una variabile, domani, di tipo data. A quel punto non bisogna ri-dichiararla (come fa la stella più brillante dell'orsa maggiore alla riga dopo...), ma si può cominciare ad usarla tranquillamente.
2b/ ancora nella riga dopo, c'è una piccola confusione nell'uso della classe nel suo complesso (domani) e nei suoi singoli attributi (oggi.dd). E' più facile capire l'errore scrivendoti la versione corretta:
domani.dd = oggi.dd+1;
3/ Infine due (2) parole in generale sulla funzione Chegiorno: ricordiamoci che essa non è più una funzione normale ma è un metodo della classe data. Questo cambia completamente la filosofia con cui dobbiamo pensarla ed usarla.
(Ripeto cose dette a lezione, ma evidentemente il cambio di paradigma della programmazione ad oggetti ha bisogno di essere digerito.)
Per capire meglio, proviamo a partire dal fondo, ovvero da quando richiamiamo il metodo. Essendo, appunto, un metodo e non una funzione stand-alone, può essere richiamata solo specificando da quale oggetto (istanza della classe) data deve essere chiamata, usando la sintassi
oggetto.metodo();
Ad esempio (volendo rimanere fedeli alla dichiarazione della coda grassa di pecora):
domani = oggi.Chegiorno(oggi);
Appare evidente, ora, il doppio ruolo dell'oggetto oggi, e forse può servire a illuminarci: ogni metodo appartiene sempre all'oggetto che lo chiama, e di quell'oggetto il metodo ha (passatemi l'iperbole) il "controllo assoluto". Se, come capiterà di norma, il metodo deve modificare (o accedere a) gli attributi dell'oggetto che lo chiama, non è necessario passargli l'oggetto come argomento! (come dicevo, sottovoce, a lezione, di fatto il compilatore fa proprio questo: passa come primo e nascosto argomento proprio il riferimento all'oggetto chiamante!)
Questo ci fa subito tornare su nel codice, alla definizione del metodo Chegiorno, e ci induce a riscriverla così:
data Chegiorno() { //nessun argomento!
data domani;
domani.dd = dd+1;
return domani;
};
in cui si notano le seguenti cose:
i) come detto, ho eliminato il parametro passato alla funzione;
ii) per accedere agli attributi dell'oggetto che chiamerà la funzione, è sufficiente far riferimento agli attributi senza specificare la classe di appartenenza (uso dd, e non oggetto.dd!): di default verranno interpretati come gli attributi dell'oggetto che sta chiamando il metodo;
iii) se invece devo far riferimento ad attributi di altri oggetti (anche della stessa classe cui appartiene il metodo), uso la solita sintassi col punto (es: domani.dd);
iv) ovviamente poi, nel main, richiamerò il metodo nel modo corretto (non come sopra), ovvero:
domani = oggi.Chegiorno();
Tutto chiaro? Questa è la programmazione ad oggetti!
:-)
Alioth ringrazia con un brillamento e un inchino a cotanta elargizione di spiegazioni!
Ora mi applicherò per digerire il tutto...A presto =)
Posta un commento