Nei libri che ho trovo che quando all'interno di un metodo richiami un metodo della medesima classe devi scrivere:
this.metodo
ma arduino sembra non accettare il termine this. Per sbaglio l'ho tolto lasciando solamente il nome del metodo chiamato, strano ma cosi'
non da errori e agisce correttamente.
C'e' un sito dove si possano trovare tali divergenze col c++ ansi?
giorgio
Secondo me dipende dall'IDE che usi per sviluppare. Ad esempio in visual basic quando devi richiamare la proprietà di un oggetto all'interno dello stesso lo potevi fare con me.quellocheè() oppure nomeoggetto.quellocheè(), se non ricordo male!
in genere si legge this->metodo();
infatti se inserisco codice come questo:
class Pippo{
void A(){}
void B(){ this->A(); }
};
viene compilato correttamente 
la differenza tra punto e freccia è dato dal fatto se si sta lavorando con puntatori o con la variabile (oggetto) direttamente. (o almeno, così funziona con le strutture in C ansi, quindi dubito che si siano discostati dallo standard)
trovo molto strano che non funzioni il this, è un comando facoltativo che alcuni dicono di mettere sempre, altri di evitarlo il più possibile (in pratica serve per richiamare una variabile o funzione locale con lo stesso nome di una esterna... cosa che sarebbe da evitare a priori. Non mi viene in mente altro, se non per passare se stessi ad un'alta funzione)
edit: this è un puntatore, quindi si usa sempre "->"
Ora ho capito, si deve usare this->metodo quando si stanno scrivendo gli oggetti.
Per me usare l'istanza della classe, anche se funziona, e' da evitare in quanto se creo due istanze una delle due non puo' andar bene.
allora in C++ this->, in Delphi Self., in Basic me.
grazie dei consigli
Ora ho capito, si deve usare this->metodo quando si stanno scrivendo gli oggetti.
NO!
devi usare -> quando hai a che fare con un puntatore (a classe o a struttura)
devi usare . quando hai a che fare con l'istanza.
this è un puntatore.
Per me usare l'istanza della classe, anche se funziona, e' da evitare
La tua stessa idea è quella cha hanno usato in molto linguaggi, nascondendo all'utente l'uso dei puntatori, ma "sottobanco" lavorano sempre per riferimento (salvo uso di tipi di dato primitivo come int, long, double etc)
Intendevo quello che dici, cioe' nella scrittura della classe (puntatori) ci va il -> OK
Difatti provenendo da Delphi li' si usa self. in tutti i casi e sono caduto nell'errore
ciao giorgio
Allora, poiché quando definisci una classe non allochi niente in memoria, se devi utilizzare un qualcosa all'interno della classe stessa non puoi sapere a priori dove si troverà il dato di interesse. Ad esempio:
Class miaclasse{
int ciao;
public:
void settavalore(int i);
int restituisci_valore();
}
miaclasse::settavalore(int i) {
this->ciao = i;
}
miaclasse:restituisci_valore() {
return this->ciao;
}
La variabile "ciao ancora non esiste da nessuna parte. Quando, nel main del programma, viene creata una istanza della classe, allora viene allocata la memoria.
miaclasse prova1;
miaclasse prova2;
Adesso ne esistono due di quelle variabili che hai creato col nome "ciao", una dentro prova1 e l'altra dentro prova2. Come fa il sistema a distinguerle? Bene, con il puntatore this. This è un puntatore che per prova1 punta a prova1 e per prova2 punta a prova2, quindi this->ciao sarà il ciao dentro prova1 per prova1 e il ciao dentro prova2 per prova2.
Quando fai prova1.settavalore(5) metti il valore 5 dentro la variabile ciao dentro l'istanza prova1, così quando fai prova1.restituisci_valore() avrai di ritorno il valore di ciao che è dentro prova1 e non quello che è dentro prova2.
Detto questo, per quanto detto qui sopra il this lo puoi omettere perché ci pensa il compilatore a fare il lavoro sporco, ma serve per farti capire a cosa serve il puntatore this. In realtà è necessario per altre cose.
Volendo è spiegato anche qui: http://www.sitoserio.it/cpp/OOP/app3.htm
OK sei stato molto dettagliato. grazie giorgio