ricerca di una parola..

[thrantir]

allora, la classe fa quello che volevi facesse la struct. Una classe puo' essere vista come una struct con associati dei metodi per operare sui dati contenuti, in seguito discuteremo il significato delle keyword "public" e "private" (ce n'e' anche un'altra, "protected").

Quindi la classe contiene una stringa e un intero, con i due metodi dichiarati possiamo sapere il valore di questi due "attributi" (cosi' si chiamano i dati dentor una classe)

calculateStringValue() calcola quanto vale la stringa passata: controlla ogni carattere in quale gruppo sta e incrementa il risultato di conseguenza.

infine calculateRate scorre una lista di stringhe e accetta un parametro di output che e' una lista di oggetti di tipo RatedString

attenzione!

la prima lista e' la lista che va scorsa, non viene mai modificata, e quindi la si passa come "const". La seconda, invece, viene modificata, quindi non si puo' passarla come const (il compilatore ti darebbe un errore)

Un altro appunto: la dichiarazione di una classe implica la creazione di uno nuovi tipo di dato astratto. Una comoda convenzione e' che i tipi di dato astratto abbiano dei nomi che inizino sempre con la lettera maiscola. Per chi ha un po di familiarita', Java segue questa coding rule

[`knives`]

azz visto cosi non era difficile.. ma arrivarci a scriverlo cosi

ora me lo studio un attimo..

[thrantir]

beh, e' tutta questione di esperienza, soprattutto nell'affrontare il problema

le regole che seguo io di solito sono:

per la definizione di nuovi tipi di dato:

se si intuisce la necessita' di una entita', si definisce una nuova classe. In questo caso, era chiaro che serviva un qualcosa che conentesse una stringa e un intero. In realta', si sarebbe potuto fare anche una mappa che avesse come chiave la stringa e come valore ;intero associato, ma, di solito, si fa una mappa quando si vogliono fare ricerce veloci con chiave

per le funzioni:

cercare di spezzettare le funzionalita' base in funzioni diverse. In questo caso, una funzionalita' necessaria era calcolare il rate di una qualsiasi stringa e un'altra era falro per una lista di stringhe. Il codice che calcola il rate si poteva anche lasciare dento il for, ma separare le due cose rende il codice piu' leggibile, anche se si perde qualcosa in termini di prestazioni (non so se sai come funziona la call di una funzione). Separare i problemi pero' ha un vantaggio: puoi ragionare piu' facilmente su un problema piu' piccolo e capire come puoi risolverlo in modo piu' furbo. Inoltre, se un giorno vuoi cambiare qualcosa, oppure vuoi addirittura avere diverse funzioni di rating e chiamare una piuttosto che un;altra, secondo un qualche criterio, e' molto piu' semplice rimaneggiare il codice

[`knives`]

avevo letto tempo fa qualcosa riguardo il tempo di esecuzione di un algortmo,
della complessita
della complessita computazionale
dell ' O_grande di qualcosa.. parli di questo?


poi certo la padronanza di un certo linguaggio di programmazione , l'esperienza la fanno da padroni in questo campo.

[thrantir]

allora, la complessita' computazionale di un algoritmo e' una misura formale, e si calcola in base ai dati di input

per esempio, se io scorro una lista lunga n, la complessita' di questa cosa e' O(n)...

invece, quello a cui mi riferivo prima, e' una perdita di efficienza dovuta al modo in cui funzionano le chiamate di una funzione

per esempio, se io ho

Codice: Seleziona tutto

void pippo()
{
    int a = 3;
    int b = 4;
    int c = a + b;
}

il compilatore trasforma questo in un codice assembler in un assegnamento di a, un assegnamento di b, una somma tra a e b e un assegnamento a c, tutte istruzioni contigue, quindi il processore le esegue direttamente

invece se io ho

Codice: Seleziona tutto

int add(int myFirst, int mySecond)
{
    return myFirst + mySecond;
}

{
    int a = 3;
    int b = 4;
    int c = add(a, b);
}


il compilatore, dopo l'assegnamento di b, scrive i valori di a e b in un po sto particolare e fa la jump alla prima istruzione della funzione add. Qui fa la somma e poi ritorna nel punto in cui aveva fatot la jump e fa l'assegnamento a c... fare una jump significa perdere tempo, non solo perche' hai una iostruzione in piu', ma perche' crei altri ritardi dovuti all'architettura parallela del processore. Per questo motivo, il c ha introdotto le macro, che sono funzioni a cui nonsi fa la jump, e il compilatore, nel momento in cui incontra la chiamata ad una macro, piglia il codice della macro e lo schiaffa dove avrebbe dovuto esserci la jump. in pratica, la chiamata alla funzione non comporta una jump ma un'espansione del codice. Il c++ ha introdotto, per lo stesso scopo, le funzioni inline. Attenzione, non tutte le macro o le funzioni inline sono espandibili, devono essere ragionevolmente semplici, senno' il compilatore le tratta come funzioni normali...

[`knives`]

Codice: Seleziona tutto

const int myElementLength = aRatedStringList.begin()->length();

const class RatedString' has no member named 'length'

[thrantir]

nella classe che abbiamo definito, RatedString appunto, non c'e' nessun metodo length(), quindi il compilatore ha ragione (ha sempre ragione, purtroppo...)

allora, immagino che tu voglia la lunghezza della stringa. hai due modi per farlo:

Codice: Seleziona tutto

const int myElementLength = aRatedStringList.begin()->getString.length();


in pratica ti fai ridare la stringa contenuta in RatedString e questa ha il metodo length(), che quindi puoi richiamare

L'altro modo e' dotare la nostra classe del metodo length()

Codice: Seleziona tutto

class RatedString
{
public:

    [....]

    int lenght() const
    {
        return theString.length();
    }

    [....]
};


una domanda, perche' l'intero a cui assegni la lunghezza della stringa e' const?

mi e' venuto in mente anche che i due metodi che abbiamo nella classe, getString e getRate, non modificano nessun attributo della classe, quindi possono essere dichiarati const. Per farlo, aggiungi const come ho fatto io nel metodo qui su

Codice: Seleziona tutto

    int lenght() const

[thrantir]

visto che sto progetto si sta espandendo, potrebbe essere meglio spezzarlo in piu' files, cosi' magari vediamo anche un po di teoria sul makefile, utile per chi vuole sviluppare sotto linux

mi sta venendo un'ideuzza...

[`knives`]

quell' intero è segnato come costante perchè non devo modificarlo, mi serve solo per sapere la lunghezza della mia parola e potermi regolare per la stampa, devo andarlo a leggere dalla stringa perchè nella creazione della aListLength(quella che ha tutti i termini di una lunghezza), se ad una determinata lunghezza non trova niente, cerca tra quelle - 1.. e cosi via.. quindi io non so piu a priori quanto mi è lunga.



per spezzettarlo in piu file e qualunque altra innovazione basta dirla e si fa sono sempre aperto a nuove idee

[`knives`]

Codice: Seleziona tutto

std::cout << myIter->getString();

passing `const RatedString' as `this' argument of `std::string& RatedString::getString()' discards qualifiers

eppure questa

Codice: Seleziona tutto

std::cout << myIter->getRate();

funziona

[thrantir]

quel metodo ritorna una stringa "const", dovrebbe funzionare se dereferenzi l'iteratore

Codice: Seleziona tutto

std::cout << *myIter.getString();


[`knives`]

Codice: Seleziona tutto

'struct std::_List_const_iterator<RatedString>' has no member named 'getString'

pero cosi facendo mi dice che myIter che è un iteratore costate non ha il metodo getString.

[thrantir]

bisognava lavorare un po di cast

Codice: Seleziona tutto

std::cout << ((RatedString)(*myIter)).getString();

[`knives`]

bisognava lavorare un po di cast

Codice: Seleziona tutto

std::cout << ((RatedString)(*myIter)).getString();

[thrantir]

in pratica, non riusciva a desumere il tipo

parti da questo

myIter e' un puntatore a un oggetto di tipo RatedString

quindi

*myIter e' un oggetto di tipo RatedString

quindi gli dico esplicitamente

(RatedString)*myIter

e questo e' sempre n oggetto di tipo rated string, del quale posso chiamare il metodo getString(), quindi

((RatedString)*myIter).getString()