Posso dichiarare una funzione che può assumere il puntatore come argomento?

Question

Leggendo una domanda in StackOverflow, mi chiedevo se è possibile dichiarare una funzione che accetta un puntatore a se stesso. Cioè per rendere tale dichiarazione di foo, per cui i seguenti sarebbe corretto:

foo(foo); 

L'idea più semplice è colata a un'altra puntatore di funzione (non possono trasmettere void*, poiché può essere più piccola), quindi la dichiarazione di funzione assomiglia a questo:

void foo(void (*)()); 

Mentre va bene in C (e funziona con getto in C++), mi chiedo, se può essere fatto senza così dura informazione "reinterpretare" casting o perdere tipo.

In altre parole, voglio la seguente dichiarazione:

void foo(void (*)(void (*)(void (*) (...)))); 

ma, ovviamente, le dichiarazioni illimitate sono impossibili. Naive typedef non aiuta neanche.

I modelli C++ sono ben accetti, anche se rendono il codice di chiamata (foo(foo)) un po 'meno sintetico, ma comunque finito.

Le risposte in stile C che mostrano come si possono eliminare informazioni di tipo senza eseguire il casting o altri trucchi del genere sono, ovviamente, interessanti, ma non saranno accettate.

Answer 1

Generalmente sono d'accordo con Dario: rendere questo a livello di tipo sembra impossibile.

Ma è possibile utilizzare le classi ("modello di strategia"):

class A { 
    void evil(A a) {  // a pointer to A is ok too 
    } 
}; 

È anche possibile aggiungere operator():

void operator()(A a) { return evil(a); } 

Generalmente tali cose sono fatte meglio in lingue FP. Versione Haskell è semplicemente:

data Evil = Evil (Evil -> Integer) 

Questo utilizza un wrapper (Evil) che corrisponde all'utilizzo di una classe.

Dall'interrogante: ciò che mancava a questa risposta era la possibilità di passare diverse funzioni come argomento di una di esse. Questo può essere risolto rendendo evil() virtuale o memorizzando esplicitamente nell'oggetto un puntatore a funzione che lo implementa (che è fondamentalmente lo stesso).

Con questo chiarimento, la risposta è sufficiente per essere accettata.

Answer 2

Apparentemente no - vedere this thread. Il tipo richiesto qui sarebbe sempre infinito.

Answer 3

Questo è un uso perfettamente valido di void *.

typedef void T(void *); 

void f(T *probably_me) 
{ 
    (*probably_me)(f); 
} 

Answer 4

Se una funzione può assumere se stessa come argomento, può eseguire la ricorsione anonima chiamando se stessa. Ma la ricorsione è impossibile nel calcolo lambda semplicemente tipizzato (che è sostanzialmente quello che hai qui, con i tipi di funzione).È necessario implementare un combinatore a virgola fissa utilizzando funzioni ricorsive o tipi ricorsivi per eseguire la ricorsione anonima.

Answer 5

Un problema correlato restituisce un puntatore di funzione dello stesso tipo. Viene fuori quando si implementano macchine a stati, quindi ha il suo entry in the C FAQ.

La stessa soluzione alternativa può essere applicata al problema.

Answer 6

Non credo che si possa avere una funzione che può assumere se stessa come argomento in C++ senza alcun tipo di inganno, come mettere la propria funzione in una classe e avere la funzione che prende quella classe come argomento.

Un altro modo che sarà possibile una volta raggiunto il nuovo standard C++ consiste nell'utilizzare lambda e fare in modo che l'acquisizione lambda stessa. Penso che sarebbe più o meno così:

auto recursive_lambda = [&recursive_lambda] { recursive_lambda(); }; 

essere avvertiti che una tale affermazione è assolutamente non testato in qualsiasi compilatore che supporta lambda. Il tuo chilometraggio può variare.

Answer 7

SI

Si tratta di una variante di "Can you write a function that returns a pointer to itself?", salvo che nel tuo caso, il tipo di funzione appare in modo ricorsivo come argumkent, non come il tipo di ritorno. La risposta di Herb Sutters è comunque riutilizzabile: avvolgere il puntatore in una classe proxy dichiarata in avanti.

Answer 8

Un altro trucco sporco.

void Foo(...) 
{ 
} 

int main() 
{ 
Foo(Foo); 
} 

Sopra il programma verrà compilato senza errori. Ma non è ricorsivo. La seguente funzione modificata è la versione ricorsiva con un limitatore.

#define RECURSIVE_DEPTH (5) 

typedef void (*FooType)(int, ...); 

void Foo(int Depth, ...) 
{ 
void (*This)(int, ...); 

va_list Arguments; 

va_start(Arguments, Depth); 

if(Depth) 
{ 
    This = va_arg(Arguments, FooType); 

    This(Depth - 1, This); 
} 

va_end (Arguments); 
} 

int main() 
{ 
Foo(RECURSIVE_DEPTH, Foo); 
}