Come dichiarare due funzioni prendendo reciprocamente la firma come argomento?

Question

E 'possibile emulare qualcosa di simile:

typedef boost::function<void(A)> B; 
typedef boost::function<void(B)> A; 

L'obiettivo principale è quello di essere in grado di scrivere codice come questo (in pseudo-C++):

void a_(B b) { 
    // ... 
    b(a_); 
} 
void b_(A a) { 
    // ... 
    f(boost::bind(a, b_)); 
} 

f(boost::bind(a_, b_)); 

Answer 1

Non direttamente possibile con typedef; ovunque si utilizza un typedef, è equivalente per il tipo di originale, quindi se si scrive

typedef boost::function<void(A)> B; 
typedef boost::function<void(B)> A; 

allora B sarebbe equivalente a boost::function<void(A)>, che equivale a boost::function<void(boost::function<void(B)>)>, e così via, fino ad arrivare

boost::function<void(boost::function<void(boost::function<void(...)>)>)> 

, che è un tipo di lunghezza infinita.

È possibile, tuttavia, definire (almeno) uno dei due tipi come struct o class:

struct A; 
typedef boost::function<void(A)> B; 
struct A 
{ 
    B b; 
    A(B b) : b(b) {} 

    // optional: 
    void operator() (A a) { b(a); } 
}; 

Potrebbe essere necessario aggiungere più costruttori e/o un operatore di conversione per fare il tipo di comportarsi completamente "trasparente", oppure si può semplicemente accedere alla struttura in modo esplicito.

Answer 2

Avete considerato utilizzando puntatori a funzione ?

#include <iostream> 

    // void (*functionPtr)() <- declaration of function pointer 
void f(void (*functionPtr)()) { 
    // execute the function that functionPtr points to 
    (*functionPtr)(); 
} 

void a() { 
    std::cout << "Function a()" << std::endl; 
} 

int main() { 
    f(a); 
} 

Ho fatto questo codice di esempio e funziona. Forse potresti usarlo.

Answer 3

La tua domanda non è tecnicamente precisa. Una firma non è qualcosa che passi come argomento. Faccio del mio meglio per dare un senso alla tua domanda.

i seguenti oggetti di funzione possono essere passati come argomento gli uni agli altri

struct foo { 
    template<typename T> void operator()(T); 
}; 

struct bar { 
    template<typename T> void operator()(T); 
}; 

foo f; bar b; 

Answer 4

sono riuscito a realizzare quello che hai descritto passando queste funzioni l'uno all'altro proprio come void*. Forse non è il modo più bello, ma funziona (l'ho provato).

typedef void (*A)(void*); 
typedef void (*B)(void*); 

void afun(void* _bf) { 
    B _bfun = (B)_bf; 
    _bfun((void*)afun); 
} 

void bfun(void* _af) { 
    A _afun = (A)_af; 
    f(boost::bind(_afun, (void*)bfun)); 
} 

int main(int argc, char** argv) { 
    f(boost::bind(afun, (void*)bfun)); 
    return 0; 
}