[C++] Array di puntatori a funzione

[Unrue]

Salve ragazzi, ho un problema nel creare un array di puntatori a funzione. Partendo dalla definizione del tipo :

typedef float (*PointerFunction)(float);

Come creo ed inizializzo un array dinamico di puntatori a funzione, le quali funzioni prendono e restituiscono un float?

Grazie.

[andbin]

ho un problema nel creare un array di puntatori a funzione. Partendo dalla definizione del tipo :

typedef float (*PointerFunction)(float);

Come creo ed inizializzo un array dinamico di puntatori a funzione, le quali funzioni prendono e restituiscono un float? Se vuoi allocare dinamicamente l'array con new (visto che parli di C++), date ad esempio due funzioni:

float func1 (float f)
{
....
}

float func2 (float f)
{
....
}

...

PointerFunction *pf = new PointerFunction[2];

pf[0] = func1;
pf[1] = func2;

[Unrue]

Così ho provato, però mi dice :

"Argument of type float(NomeClasse:: )float does not match float(*)(float) ";

La funzione membro alla quale voglio collegarlo è del tipo float Nomefunzione(float);

Quindi non capisco perchè dica questa cosa.

[andbin]

La funzione membro alla quale voglio collegarlo è del tipo float Nomefunzione(float);No alt aspetta. Parli di una funzione membro di una classe??? No non è la stessa cosa (e il 'this' che fine farebbe? :D ).

Sono un po' "arruginito" per il C++ ma credo che non si possa fare. Si potrebbe fare, se non sbaglio, se la funzione membro è 'static'.

[tomminno]

Così ho provato, però mi dice :

"Argument of type float(NomeClasse:: )float does not match float(*)(float) ";

La funzione membro alla quale voglio collegarlo è del tipo float Nomefunzione(float);

Quindi non capisco perchè dica questa cosa.

Allora non vuoi un puntatore a funzione ma un puntatore a metodo.
che si dichiara con:

typedef float (NomeClasse::*PointerFunction)(float);

[Unrue]

Ah ecco,quindi dovrei dichiarare le funzioni static. Però in realtà non è necessario che lo siano,per quanto riguarda il design dell'applicazione metterei static solo per fare questa cosa.

[Unrue]

Allora non vuoi un puntatore a funzione ma un puntatore a metodo.
che si dichiara con:

typedef float (NomeClasse::*PointerFunction)(float);

Così funziona!

Poi l'assegnamento lo faccio con :

array_func_experts[0]=&NomeClasse::nomefunzione;
...

Grazie!! :)

[andbin]

No mi correggo, si può fare:

class Prova
{
public:
void test (void) { cout << "hello" << endl; }
};

typedef void (Prova::*ptr) (void);

poi ad esempio:

ptr p = &Prova::test;
Prova prova;

(prova.*p) ();


(io comunque eviterei menate del genere ..... anzi eviterei del tutto il C++ :D )

[tomminno]

No alt aspetta. Parli di una funzione membro di una classe??? No non è la stessa cosa (e il 'this' che fine farebbe? :D ).

Sono un po' "arruginito" per il C++ ma credo che non si possa fare. Si potrebbe fare, se non sbaglio, se la funzione membro è 'static'.

Lo puoi fare anche se i metodi non sono static, ci mancherebbe, se però imposti il puntatore ad un metodo di una classe non istanziata, non c'è try/catch che ti salvi.

[andbin]

Lo puoi fare anche se i metodi non sono staticInfatti ... mi sono ricordato, grazie.
Io comunque tifo per Java ... non per C++. ;)

[Unrue]

Allora ragazzi, adesso ho il problema di invocare queste funzioni!

Ho provato così :

Puntatoreclasse->array_funzioni[0](float di ingresso);

Ma non funziona. Come si invoca? Tenete conto che lo sto invocando da un'altra classe, non da quella da cui l'ho definito.

[andbin]

Allora ragazzi, adesso ho il problema di invocare queste funzioni!

Ho provato così :

Puntatoreclasse->array_funzioni[0](float di ingresso);

Ma non funziona. Come si invoca?Vedi il mio esempio sopra.

[tomminno]

Allora ragazzi, adesso ho il problema di invocare queste funzioni!

Ho provato così :

Puntatoreclasse->array_funzioni[0](float di ingresso);

Ma non funziona. Come si invoca? Tenete conto che lo sto invocando da un'altra classe, non da quella da cui l'ho definito.

Gli operatori per puntatori a metodo sono ->* e .*

[Unrue]

Gli operatori per puntatori a metodo sono ->* e .*

Ho provato :

Puntatoreclasse->*(array_punt_funzioni[0]))(ingresso);

Ma non funziona

[Unrue]

Provato anche questo, ma nulla :

(Puntatoreclasse->*array_punt_funzione[0])(ingresso)

[tomminno]

Infatti ... mi sono ricordato, grazie.
Io comunque tifo per Java ... non per C++. ;)

Vabbè, ma altrimenti come fai a far comunicare le classi C++ tra di loro?

Inoltre si può scaricare l'header fastdelegate da codeproject che rende la sintassi più leggibile e decisamente più comoda da usare.
Assegni i puntatori a metodo con MakeDelegate(this,&NomeClasse::Metodo) e puoi usare indifferentemente puntatori a funzione e a metodo.

[tomminno]

Provato anche questo, ma nulla :

(Puntatoreclasse->*array_punt_funzione[0])(ingresso)

Potresti postare il codice?

[Unrue]

Potresti postare il codice?

Il codice è piuttosto grande, cosa ti serve di preciso?

[tomminno]

Il codice è piuttosto grande, cosa ti serve di preciso?

il punto in cui dichiari array_punt_funzione e Puntatoreclasse, anche per capire se la dichiarazione di Puntatoreclasse ha senso rispetto a quello che vuoi fare.

[Unrue]

Ho risolto così :

(Puntatoreclasse->* (Puntatoreclasse->array_punt_func[0]))(ingresso);

[tomminno]

Ho risolto così :

(Puntatoreclasse->* (Puntatoreclasse->array_punt_func[0]))(ingresso);

Quindi array_punt_func è un membro pubblico della classe identificata da Puntatoreclasse?
A che ti serve fare così? Non sarebbe meglio se fosse un array dichiarato all'interno della classe che istanzia Puntatoreclasse?

[Unrue]

Quindi array_punt_func è un membro pubblico della classe identificata da Puntatoreclasse?
A che ti serve fare così? Non sarebbe meglio se fosse un array dichiarato all'interno della classe che istanzia Puntatoreclasse?

No perchè serve a tutte e due le classi. Metterla in una o nell'altra è la stessa cosa. Non essendoci una gerarchia tra le due classi( perchè avrebbe poco senso per la logica del programma), ho scelto questa strada.

[homer87]

Io faccio sempre così:


int b;

//Inizializza la classe...
ClasseX *nomeclasse;

nomeclasse->funzione();

b=nomeclasse->var;


Vedi come ti suona?

[tomminno]

No perchè serve a tutte e due le classi. Metterla in una o nell'altra è la stessa cosa. Non essendoci una gerarchia tra le due classi( perchè avrebbe poco senso per la logica del programma), ho scelto questa strada.

Così violi l'incapsulamento.
Se la classe di Puntatoreclasse per un qualche motivo avesse bisogno di modificare l'ordine dei metodi in array_punt_func non funzionerebbe più niente.
La gerarchia c'è eccome, una è la classe chiamante che dovrebbe interagire con il chiamato solo tramite metodi pubblici.
Sinceramente mi sfugge il perchè del tuo design, mi sembra che tu possa fare equivalentemente esponendo un metodo pubblico.

[tomminno]

Io faccio sempre così:


int b;

//Inizializza la classe...
ClasseX *nomeclasse;

nomeclasse->funzione();

b=nomeclasse->var;


Vedi come ti suona?

Le variabili pubbliche mi suonano molto male ;)

[homer87]

Le variabili pubbliche mi suonano molto male ;)


Vero :doh: , scusate l'errore.
Comunque io intendevo così:

int var(){
//bla bla
return var;
}

e poi
b=nomeclasse->var();


E' proprio vero che la fretta... :muro:

EDIT:
Magari ci puoi inserire dei valori in entrata tipo int var(int index)
In modo da regolare l'array e tutte le altre menate che ti servono.
E utilizzare la funzione con:
m=nomeclasse->var(4);

[Unrue]

Così violi l'incapsulamento.
Se la classe di Puntatoreclasse per un qualche motivo avesse bisogno di modificare l'ordine dei metodi in array_punt_func non funzionerebbe più niente.
La gerarchia c'è eccome, una è la classe chiamante che dovrebbe interagire con il chiamato solo tramite metodi pubblici.
Sinceramente mi sfugge il perchè del tuo design, mi sembra che tu possa fare equivalentemente esponendo un metodo pubblico.

Ma i metodi nell'array di funzioni sono pubblici nella classe di definizione. Forse intendi metodi globali?

[tomminno]

Ma i metodi nell'array di funzioni sono pubblici nella classe di definizione. Forse intendi metodi globali?

Appunto se sono pubblici a che serve usare il puntatore a metodo?
La sintassi che hai usato

(Puntatoreclasse->* (Puntatoreclasse->array_punt_func[0]))(ingresso);

significa che richiami un metodo della classe "PuntatoreClasse" specificato da array_punt_func[0].
Se questo metodo è pubblico perchè non usare:

Puntatoreclasse->MetodoPubblico0(ingresso);

:confused:

[Unrue]

Appunto se sono pubblici a che serve usare il puntatore a metodo?


Perchè li richiamo con un array di funzioni,non direttamente.. A priori non so quale sia il metodo da chiamare.

[tomminno]

Perchè li richiamo con un array di funzioni,non direttamente.. A priori non so quale sia il metodo da chiamare.

Se non conosci il metodo da chiamare come fai a sapere che parametri passargli? :mbe:
Solo PuntatoreClasse sa come ha riempito quell'array, dall'esterno come fai a sapere cosa ha messo in posizione 0 e quindi a passargli i dati necessari?

Devi per forza presupporre dall'esterno che il criterio di riempimento di quell'array non cambierà, ma quel criterio è un qualcosa di "privato" della classe PuntatoreClasse.

Secodo me c'è un problema di design delle classi.

[Unrue]

Se non conosci il metodo da chiamare come fai a sapere che parametri passargli? :mbe:
Solo PuntatoreClasse sa come ha riempito quell'array, dall'esterno come fai a sapere cosa ha messo in posizione 0 e quindi a passargli i dati necessari?


Sono io che riempo quell'array, quindi so esattamente che funzione c'è nella posizione i-esima. Quello che non so è quale funzione verrà chiamata. Inoltre riguardo i parametri passati,tutte le funzioni nell'array prendono un float e restituiscono un float, quindi il problema non si pone. Se guardi l'inizio del post,vedrai che ho riempito l'array di puntatori a funzioni con questo tipo di puntatore a funzione:

typedef float (NomeClasse::*PointerFunction)(float);

Ogni volta che non sappiamo quale funzione verrà chiamata, si usano dei puntatori a funzione. La mia unica differenza è che le funzioni che chiamo sono funzioni membro. Questa tecnica è anche nel libro di Stroustrup, nel paragrafo "Puntatori a membri", quindi non mi pare di aver fatto una cosa sciocca.

[tomminno]

Sono io che riempo quell'array, quindi so esattamente che funzione c'è nella posizione i-esima.


Non è così che funziona la programmazione ad oggetti.
Se te creatore della classe NomeClasse sai cosa ci metti in quell'array non così è per chi scrive una classe "UsaNomeClasse".

Magari mi risponderai che sei sempre te a scrivere "UsaNomeClasse", ma la questione non cambia.
Leghi la funzionalità di chi usa la classe NomeClasse alla conoscenza di come questa funziona internamente, che è l'esatto opposto di quello che si prefigge la OOP.


Quello che non so è quale funzione verrà chiamata.


Quello che non capisco è se non sai quale metodo richiami come fai a passargli dei parametri corretti?
Indipendentemente dal metodo quei parametri sai che sono corretti?
Cioè il parametro input è corretto per qualunque metodo in array_punt_func?


Inoltre riguardo i parametri passati,tutte le funzioni nell'array prendono un float e restituiscono un float, quindi il problema non si pone. Se guardi l'inizio del post,vedrai che ho riempito l'array di puntatori a funzioni con questo tipo di puntatore a funzione:

typedef float (NomeClasse::*PointerFunction)(float);


Questo dice poco se per caso fosse:

float NomeClasse::SetMax(float newMax)
{
max = newMax;
return max;
}

float NomeClasse::SetMin(float newMin)
{
min = newMin;
return min;
}

void NomeClasse::Init()
{
array_punt_func[0] = &NomeClasse::SetMax;
array_punt_func[1] = &NomeClasse::SetMin;
}


già solo cambiare l'Init in:


void NomeClasse::Init()
{
array_punt_func[0] = &NomeClasse::SetMin;
array_punt_func[1] = &NomeClasse::SetMax;
}


Ti stravolgerebbe il funzionamento.


Ogni volta che non sappiamo quale funzione verrà chiamata, si usano dei puntatori a funzione. La mia unica differenza è che le funzioni che chiamo sono funzioni membro. Questa tecnica è anche nel libro di Stroustrup, nel paragrafo "Puntatori a membri", quindi non mi pare di aver fatto una cosa sciocca.

Nella versione elettronica del libro di Stroustrup non mi risultano esempi di puntatori a membro usati all'interno di classi.

Comunque puoi star certo che non hai programmato correttamente ad oggetti. ;)

[Unrue]

Non è così che funziona la programmazione ad oggetti.
Se te creatore della classe NomeClasse sai cosa ci metti in quell'array non così è per chi scrive una classe "UsaNomeClasse".

Magari mi risponderai che sei sempre te a scrivere "UsaNomeClasse", ma la questione non cambia.
Leghi la funzionalità di chi usa la classe NomeClasse alla conoscenza di come questa funziona internamente, che è l'esatto opposto di quello che si prefigge la OOP.


Mi sono spiegato male. L'array di puntatori a funzione lo riempo io nel senso che le funzioni da inserire le leggo da un file di configurazione. Quindi chi scrive tale file non gli serve di sapere come è fatta internamente la classe, deve solo scrivere correttamente tale file.

Quello che non capisco è se non sai quale metodo richiami come fai a passargli dei parametri corretti?

Forse è necessario dare un pò più di dettagli del mio progetto. Queste funzioni sono legate ai livelli di una rete neurale. Ogni livello ha le stesse funzioni sui neuroni, quindi, una volta stabilito in che livello sono,ecco che capisco quale funzione, nell'array di puntatori a funzioni, va chiamata. I parametri che prende in ingresso sono i segnali dei neuroni del livello precedente.


Comunque puoi star certo che non hai programmato correttamente ad oggetti

Uff, è la seconda volta che lo dici. Scusa ma te come fai a chiamare una funzione membro senza sapere a priori quale sia? Se conosci un metodo migliore dimmelo pure..

[tomminno]

Forse è necessario dare un pò più di dettagli del mio progetto. Queste funzioni sono legate ai livelli di una rete neurale. Ogni livello ha le stesse funzioni sui neuroni, quindi, una volta stabilito in che livello sono,ecco che capisco quale funzione, nell'array di puntatori a funzioni, va chiamata. I parametri che prende in ingresso sono i segnali dei neuroni del livello precedente.



Uff, è la seconda volta che lo dici. Scusa ma te come fai a chiamare una funzione membro senza sapere a priori quale sia? Se conosci un metodo migliore dimmelo pure..

Quindi l'indice dell'array si riferisce al livello nella rete di neuroni?
Se è così che senso ha avere tutti questi metodi all'interno di una sola classe?
Non è meglio creare una interfaccia con un metodo pubblico del tipo
float Metodo(float)
e istanziare tante classi quanti sono i livelli necessari?

Così facendo avrai una classe che legge il file di configurazione che restituirà l'elenco dei livelli da istanziare, una classe "Manager" si occuperà di istanziare (magari tramite il pattern factory method) tante classi "LivelloRete" quante sono quelle impostate, a quel punto per ogni livello non farai altro che richiamare la classe apposita che conterrà solo metodo specifico per quel livello. Tutto senza bisogno di esporre variabili.

Mi sembra che la struttura che utilizzi sia più orientata al C che non al C++. ;)

[Unrue]

Quindi l'indice dell'array si riferisce al livello nella rete di neuroni?
Se è così che senso ha avere tutti questi metodi all'interno di una sola classe?
Non è meglio creare una interfaccia con un metodo pubblico del tipo
float Metodo(float)
e istanziare tante classi quanti sono i livelli necessari?

Così facendo avrai una classe che legge il file di configurazione che restituirà l'elenco dei livelli da istanziare, una classe "Manager" si occuperà di istanziare (magari tramite il pattern factory method) tante classi "LivelloRete" quante sono quelle impostate, a quel punto per ogni livello non farai altro che richiamare la classe apposita che conterrà solo metodo specifico per quel livello. Tutto senza bisogno di esporre variabili.

Mi sembra che la struttura che utilizzi sia più orientata al C che non al C++. ;)

Certo che si può fare. Solo che in tal modo secondo me si perde un pò di logica. Attualmente una classe mi indentifica una rete neurale, con i suoi vari livelli, funzioni di attivazione, pesi e così via. Se accedo a quella classe, lì dentro trovo già tutto quello che mi serve. Inoltre facendo così l'unica cosa un pò "grezza" che sono costretto a fare è questa cosa dei puntatori a membri. Ma è accettabile a fronte di una maggiore chiarezza del codice. Usare classi per un solo livello della rete non mi piace molto. Ci avevo già pensato comunque, per poi optare per la soluzione attuale. Cambiare design solo per non usare puntatori a membro mi sembra un pò eccessivo.

Ovviamente vi sono più implementazioni possibili per ogni progetto, quindi anche la tua è una valida alternativa :)

[tomminno]

Certo che si può fare. Solo che in tal modo secondo me si perde un pò di logica. Attualmente una classe mi indentifica una rete neurale, con i suoi vari livelli, funzioni di attivazione, pesi e così via. Se accedo a quella classe, lì dentro trovo già tutto quello che mi serve. Inoltre facendo così l'unica cosa un pò "grezza" che sono costretto a fare è questa cosa dei puntatori a membri. Ma è accettabile a fronte di una maggiore chiarezza del codice. Usare classi per un solo livello della rete non mi piace molto. Ci avevo già pensato comunque, per poi optare per la soluzione attuale. Cambiare design solo per non usare puntatori a membro mi sembra un pò eccessivo.

Ovviamente vi sono più implementazioni possibili per ogni progetto, quindi anche la tua è una valida alternativa :)

Magari potresti nascondere l'array di puntatori tramite un metodo a cui passi l'indice del livello e i parametri, così puoi anche controllare anche se viene passato un indice fuori range, che nel tuo caso sarebbe decisamente catastrofico. ;)

[Unrue]

Magari potresti nascondere l'array di puntatori tramite un metodo a cui passi l'indice del livello e i parametri, così puoi anche controllare anche se viene passato un indice fuori range, che nel tuo caso sarebbe decisamente catastrofico. ;)

Certamente! E' una delle prossime cose da fare.