[C] matrice dinamica di puntatori a funzione

[trallallero]

Non riesco a dichiarare una matrice dinamica di puntatori a funzione.

In questo senso:
questa e´ fissa a 10 * 10
void(*x[10][10])();

ma a me servirebbe una dichiarazione di puntatore a puntarore, tipo
int **x;
perche´ non so quante funzioni avro´.

Se la faccio cosi´ mi da errore (giustamente):
void(*x[][])();
xxx.c:11: error: array type has incomplete element type



Mi sto inventando un sistema a stati dinamico sia in verticale che orizzontale e ogni stato ha quindi una serie di funzioni ma non posso (potrei ma non voglio) sapere ne quanto stati avro´ ne quante azioni per ogni stato.

Ma si puo´ fare ?
:help:

[andbin]

Non riesco a dichiarare una matrice dinamica di puntatori a funzione.Una cosa così:
typedef void (*PFUNC)();


PFUNC **mat;
int righe=10, colonne=10;
int i;

mat = (PFUNC**) malloc (righe * sizeof (PFUNC*));

for (i = 0; i < colonne; i++)
mat[i] = (PFUNC*) malloc (colonne * sizeof (PFUNC));


...

mat[0][0] = una_funzione;
...

[trallallero]

Una cosa così:
typedef void (*PFUNC)();


PFUNC **mat;
int righe=10, colonne=10;
int i;

mat = (PFUNC**) malloc (righe * sizeof (PFUNC*));

for (i = 0; i < colonne; i++)
mat[i] = (PFUNC*) malloc (colonne * sizeof (PFUNC));


...

mat[0][0] = una_funzione;
...
la typedef :doh:

minkia andbin, ne sai una piu´ del diavolo :D

grazie

[nuovoUtente86]

non ho ben capito cosa devi fare ,ma sembra interessante.

[Baronerosso9]

Mi*chia... Andbin....sei davvero un mostro!!!:eek: Io mi ci stavo scervellando....:D
Non avevo mai colto fino ad ora la grande funzionalità del typedef....wow...ti ringrazio ank'io!!!! Bravo!!!!;)

[trallallero]

Mi*chia... Andbin....sei davvero un mostro!!!:eek: Io mi ci stavo scervellando....:D
Non avevo mai colto fino ad ora la grande funzionalità del typedef....wow...ti ringrazio ank'io!!!! Bravo!!!!;)
infatti anche io la uso poco, di solito solo per definire nuovi tipi semplici, invece in questo caso mi sembra l´unica soluzione.

non ho ben capito cosa devi fare ,ma sembra interessante.
comunicazione tra client-server dove quasi ogni client e´ anche server e viceversa, perche´ inseriti in un catena
client -> server/client <-> server/client <-> ... <-> db

Ogni comunicazione e´ gestita da sistemi a stati (state machines) e nonostante abbiano fatto un ottimo lavoro di basso livello (send/recv msg, liste etc ... io sono entrato a meta´ progetto), la gestione medio alto livello e´ fatta male, secondo me. L´ho fatto notare e m´han detto che non hanno trovato una soluzione valida. Abbiamo quindi queste state machines enormi, illeggibili, difficili da modificare.

Sarebbe bastato una diverso stile, secondo me, perche´ lo stesso tipo che ha fatto un ottimo lavoro di basso livello, quando deve fare per esempio un send ACK, copia e incolla il codice ovunque, usando le sue funzioni, senza creare un' altra funzione di medio livello tipo sendACK(). E non ho capito perche´ :boh: (io le ho fatte ma non le ha usate lo stesso)

Quindi ho pensato di creare un sistema che permette di "viaggiare" tra gli stati in maniera dinamica (recentemente abbiamo avuto l´esigenza di aggiungere uno stato e non e´ stato facile modificare il sorgente).

Quindi, ho pensato, in una matrice abbiamo, in verticale, gli stati, in orizzontale tutti le azioni per ogni stato e ogni azione e´ una funzione.
Ogni funzione setta il nuovo livello (orizzontale) e, se serve, il nuovo stato.

Non posso sapere quanti stati ci saranno tantomeno quante azioni ogni stato dovra´ avere, quindi l´unica via mi sembra quella di una matrice dinamica di puntatori a funzione.

Non so se mi sono capito bene :D

Se qualcuno ha altre idee ben vengano

[mastoo]

giusto per curiosità
ma

void (*(**x))()

questo non è un vettore bidimensionale di puntatori a funzione che ritorna un void
corregetemi se sbaglio

[Baronerosso9]

giusto per curiosità
ma

void (*(**x))()

questo non è un vettore bidimensionale di puntatori a funzione che ritorna un void
corregetemi se sbaglio

penso che basti questo:

void (**x)();

[trallallero]

penso che basti questo:

void (**x)();

le stavo provando un po tutte ma c´e´ poi da diventare matti nel cast della malloc. Alla fine anche se c´e´ una soluzione alternativa, la migliore rimane la typedef per leggibilita´

[trallallero]

allora, ho scoperto che e´ una boiata:

void (***x)();
...
x = malloc( lines * sizeof(void**) );
...
x[i] = malloc( columns * sizeof(void*) );


ovviamente la typedef e´ la soluzione migliore a livello di leggibilita´, ma non era cosi´ assurda come sembrava.
Il primo * per dire che e´ un pointer, il secondo per dire che e´ array etc.

[trallallero]

L´idea e´ piaciuta :yeah: e mo´ tocca implementarla :eek:

Avrei un quesito su una cosa un po´ strana (per me almeno, e´ la prima volta che mi serve).

Sto creando una struttura in C a mo´ di classe C++ che ovviamente non puo´ contenere funzioni ma solo puntatori ad esse.
Ho creato una funzione che setta i puntatori di questa benedetta matrice di puntatori a funzione, ho inserito il puntatore
alla funzione nella struttura:
void (*SetActions)( int Rows, int Columns, void** ppFuncs );

Adesso la domanda:
non c´e´ un modo per non dover assegnare al puntatore la funzione ogni volta che dichiaro una di queste strutture ma che sia automaticamente settato per default ?
In pratica mi manca il costruttore del C++ dove ci schiaffi tutto cio´ che ti serve all´inizio :stordita:

Perche´ senno´ e´ inutile un puntatore ad una funzione esterna, la lascio esterna e le passo anche la struttura, tipo:
void (*SetActions)( CommStruct* pStruct, int Rows, int Columns, void** ppFuncs );

tanto non mi caghera´ nessuno, tutti in ferie siete :sob: