Salve a tutti,
sto cercando di scrivere del codice in Arduino utilizzando i paradigmi del c++, ma a quanto pare di strutturato questo linguaggio consente ben poco! In particolare ho dei problemi con:
funzioni friend
passaggio di oggetti a funzioni non membro di altre classi
Siccome ho letto la documentazione ufficiale dell'AVR e le limitazioni del linguaggio Arduino rispetto al C++, ed i casi precedenti non sono contemplati, volevo sapere se c'è qualcuno che è riuscito ad ovviare al problema !
Vi ringrazio anticipatamente.
Ciao.
No so, io penso che le friend dovrebbero esserci, dicci qual’e l’errore che riscontri.
Che significa “passaggio di oggetti a funzioni non membro di altre classi”?
La funzione a cui vuoi passare un’oggetto non è membro di nessuna classe:
Un passaggio di un’oggetto String ad una funzione lavora, ne sono sicuro.
In passato ho letto che il preprocessore di Arduino alle volte non fa quello che dovrebbe rendendo impossibile la compilazione di alcuni codici, per cui posta un’esempio non funzionante così anche altri lo possono provare.
Allora, per passaggio di un oggetto ad una funzione non appartenente a nessuna classe intendevo dire il passaggio di un’istanza di una classe ad una funzione che non è membro di nessuna classe.
Un esempio di codice potrebbe essere questo:
class Classe
{
int dato;
public:
Classe() { dato=0;}
int get_dato() { return dato ;}
friend void modifica_dato(Classe* obj,int data);
};
void funzione(Classe* obj); //questo è il passaggio dell'istanza della classe ad una funzione non membro di alcuna classe
Classe nuova_classe;
void setup()
{
Serial.begin(9600);
}
void loop()
{
funzione(& nuova_classe);
modifica_dato(& nuova_classe, 5);
funzione(& nuova_classe);
for (; ;)
;
}
void modifica_dato(Classe* obj,int data)
{
obj->dato=data;
}
void funzione(Classe* obj)
{
Serial.println(obj->get_dato());
}
A me non funziona e non capisco il motivo!
Se volete verificare che il problema non sia il codice questa è la versione c++,ovviamente funzionante:
#include<iostream>
using namespace std;
class Classe
{
int dato;
public:
Classe() { dato=0;}
int get_dato() { return dato ;}
friend void modifica_dato(Classe* obj,int data);
};
void funzione(Classe* obj); //questo è il passaggio dell'istanza della classe ad una funzione non membro di alcuna classe
main()
{
Classe nuova_classe;
funzione(& nuova_classe);
modifica_dato(& nuova_classe, 5);
funzione(& nuova_classe);
system("PAUSE");
}
void modifica_dato(Classe* obj,int data)
{
obj->dato=data;
}
void funzione(Classe* obj)
{
cout<<obj->get_dato();
cout<<"\n\n";
}
ok ho visto ed in effetti sembra proprio fatto apposta XD....cmq leggendo i post riguardano problematike ben differenti. Bhè cmq cancelliamo sti post altrimenti non mi risponde più nessuno!!
Ora non posso provare ho altro per le mani, anche perchè non uso Arduino core ecc, ma il modo classico di sviluppare i C/C++ quindi con il main() ecc.
Dovresti dare altre info:
Sistema Operativo?
Versione di Arduino IDE?
Con quale compilatore hai provato il codice sul PC, cioè quello funzionante.
Errore in compilazione? Errore a runtime (non esegue quello che gli hai detto)
Io ho un dubbio "friend void modifica_dato(Classe* obj,int data);" è presente nella classe ma non c'è nessun riferimento risolvibile prima di questa dichiarazione, cioè il compilatore potrebbe dire ok, mi aspetto di trovare nel codice una funzione con quel nome, oppure non trovando una dichiarazione di quella funzione si ferma non sapendo che fare.
Allora, il codice C++ è funzionante con DEV C++.
Per quanto riguarda la funzione "friend void modifica_dato(Classe* obj,int data);" non vedo il problema:
ho dichiarato il prototipo della funzione nella classe, dicendo al compilatore ke la funzione è friend di quella classe. Successivamente ho definito il corpo della funzione, quindi il problema " è presente nella classe ma non c'è nessun riferimento risolvibile prima di questa dichiarazione, cioè il compilatore potrebbe dire ok, mi aspetto di trovare nel codice una funzione con quel nome, oppure non trovando una dichiarazione di quella funzione si ferma non sapendo che fare." , non c'è!
Per il resto, anche il semplice passaggio dell'istanza di una classe ad una funzione non membro "void funzione(Classe* obj);" non funziona, quindi mi sto convincendo ke sono tutti problemi che uno si deve aspettare quando utilizza una piattaforma come Arduino.
Bhè cmq grazie x le risposte....magari se puoi provarlo mi dai un'ulteriore conferma...
Ciao!
Aggiungo un'altra cosa che potrebbe tornare utile a qualkuno: se si passa un'istanza di una classe ad una funzione membro di un'altra classe, tutto funziona correttamente ad es:
class B;
class A
{ // quello k è
public:
void funzioneA(B obj);
};
class B
{
//quello ke è
};
Mha!!
Chissà ke regole strane saranno implementate....xò bastava documentarle!!!
Ciao, sono un programmatore C++, anche se un po' arrugginito.
La soluzione più semplice è usare un design pattern chiamato abstract factory: deleghi ad una funziona la creazione della sottoclasse specifica che ti serve.
E' più semplice da mantenere e non rischi di farti male con puntatori vari...hai un solo punto dove decidi la tua istanza...
Però ricorda che Arduino ha solo 2Kb di Ram e 32KB di spazio per il codice... io stesso ho ridotto all'osso i framework, tenedomi solo un piccolo sistema bastato su eventi.
Ciao Daitangio,
grazie x la risposta!
Allora, di abstract factory non avevo mai sentito parlare...xò leggendo un pò ho potuto notare ke contestualizzato al c++, non è altro ke il concetto,a me noto, di funzioni e classi virtuali! Ammesso ke con Arduino funzionino(non ho provato) potrei definire una classe base, in cui inserire una funzione virtuale, e successivamente ridefinire tale funzione in ciascuna delle classi derivate dalla classe base. Così posso ottenere il polimorfismo in esecuzione : definendo un puntatore alla classe base,posso "chiamare" la versione della funzione ke mi interessa, semplicemente con la notazione p->funzione, e sarà l'indirizzo assegnato a p a definire, in esecuzione, quale versione della funzione chiamare!
Xò la mia esigenza è molto più semplice: mi serve solo poter passare un' istanza di una classe ad una funzione ke non sia membro di alcuna classe.
Chiedevo delle funzioni friend, xkè quella mi era parsa una buona alternativa, purtroppo neanke le funzioni friend si comportano come dovrebbero.
Daitangio, io no riesco a vederla la soluzione con le funzioni virtuali....tu a cosa avevi pensato in concreto?
Ciao!
Aggiungo una cosa x completezza ke potrebbe servire a coloro ke si dovessero trovare nella mia situazione.
Nei post precedenti ho detto ke le funzioni friend non funzionano, mi correggo dicendo ke non funzionano come dovrebbero.
Le funzioni friend funzionano ma solo se si dichiara il corpo della funzione inline... per capirci:
class Classe
{
int dato;
public:
Classe() { dato=0;}
int get_dato() { return dato ;}
friend void modifica_dato(Classe* obj,int data) { obj->dato=data;}
};
Il motivo è lo stesso che non permette di passare un'istanza di una classe ad una funzione non membro di alcuna classe, e che permette di usare una funzione senza averne dichiarato il prototipo precedentemente (questo non vale solo per le funzioni membro di una classe), legato chiaramente alla logica" smart & quickly" intrinseca di Arduino.
In ogni caso queste pseudo funzioni friend non hanno niente a ke fare con le funzioni friend del C++ : se non si può fare una dichiarazione in avanti di una classe e queste "friend" non possono essere friend di più di una classe( il messaggio d'errore è ke l'ho definita già da un'altra parte quella funzione...ma no? XD) kissa a kosa potrebbero servire ste pseudo funzioni!!
e poi...ci sono tante altre cose ke ho trovato -.-".....
Vabbè...era giusto per fare chiarezza su quello che avevo scritto.
Ciao!
