C/C++ macro/modello blackmagic per generare un nome univoco

Question

Le macro vanno bene. I modelli vanno bene. Praticamente qualunque cosa funzioni va bene.

L'esempio è OpenGL; ma la tecnica è specifica per C++ e non si basa sulla conoscenza di OpenGL.

problema preciso:

voglio un'espressione E; dove non devo specificare un nome univoco; tale che un costruttore è chiamato dove E è definito, e un distruttore è chiamato dove il blocco E è in fine.

Ad esempio, si consideri:

class GlTranslate { 
    GLTranslate(float x, float y, float z); { 
    glPushMatrix(); 
    glTranslatef(x, y, z); 
    } 
    ~GlTranslate() { glPopMatrix(); } 
}; 

soluzione manuale:

{ 
    GlTranslate foo(1.0, 0.0, 0.0); // I had to give it a name 
    ..... 
} // auto popmatrix 

Ora, ho questo non solo per glTranslate, ma un sacco di altre PushAttrib/PopAttrib chiamate anche. Preferirei non dover inventare un nome univoco per ogni var. C'è qualche trucco che coinvolge i modelli di macro ... o qualcos'altro che creerà automaticamente una variabile il cui costruttore è chiamato al punto di definizione; e il distruttore chiamato alla fine del blocco?

Grazie!

Answer 1

Se il compilatore supporta __COUNTER__ (probabilmente fa), si potrebbe provare:

// boiler-plate 
#define CONCATENATE_DETAIL(x, y) x##y 
#define CONCATENATE(x, y) CONCATENATE_DETAIL(x, y) 
#define MAKE_UNIQUE(x) CONCATENATE(x, __COUNTER__) 

// per-transform type 
#define GL_TRANSLATE_DETAIL(n, x, y, z) GlTranslate n(x, y, z) 
#define GL_TRANSLATE(x, y, z) GL_TRANSLATE_DETAIL(MAKE_UNIQUE(_trans_), x, y, z) 

Per

{ 
    GL_TRANSLATE(1.0, 0.0, 0.0); 

    // becomes something like: 
    GlTranslate _trans_1(1.0, 0.0, 0.0); 

} // auto popmatrix 

Answer 2

Non lo farei personalmente, ma ho appena trovato nomi univoci. Ma se si vuole fare, in un modo è quello di utilizzare una combinazione di if e for:

#define FOR_BLOCK(DECL) if(bool _c_ = false) ; else for(DECL;!_c_;_c_=true) 

è possibile utilizzarlo come

FOR_BLOCK(GlTranslate t(1.0, 0.0, 0.0)) { 
    FOR_BLOCK(GlTranslate t(1.0, 1.0, 0.0)) { 
    ... 
    } 
} 

Ognuno di questi nomi sono in ambiti separati e ha vinto' t conflitto I nomi interni nascondono i nomi esterni. Le espressioni nei loop if e for sono costanti e dovrebbero essere facilmente ottimizzate dal compilatore.

---

Se davvero si vuole passare un'espressione, è possibile utilizzare il trucco ScopedGuard (vedi Most Important const), ma avrà bisogno di un po 'più di lavoro per scriverlo. Ma la parte bella è che siamo in grado di sbarazzarsi del ciclo for, e lasciare che il nostro oggetto valutare per false:

struct sbase { 
    operator bool() const { return false; } 
}; 

template<typename T> 
struct scont : sbase { 
    scont(T const& t):t(t), dismiss() { 
    t.enter(); 
    } 
    scont(scont const&o):t(o.t), dismiss() { 
    o.dismiss = true; 
    } 
    ~scont() { if(!dismiss) t.leave(); } 

    T t; 
    mutable bool dismiss; 
}; 

template<typename T> 
scont<T> make_scont(T const&t) { return scont<T>(t); } 

#define FOR_BLOCK(E) if(sbase const& _b_ = make_scont(E)) ; else 

È quindi fornire i corretti enter e leave funzioni:

struct GlTranslate { 
    GLTranslate(float x, float y, float z) 
    :x(x),y(y),z(z) { } 

    void enter() const { 
    glPushMatrix(); 
    glTranslatef(x, y, z); 
    } 

    void leave() const { 
    glPopMatrix(); 
    } 

    float x, y, z; 
}; 

Ora può scrivere interamente senza nome sul lato utente:

FOR_BLOCK(GlTranslate(1.0, 0.0, 0.0)) { 
    FOR_BLOCK(GlTranslate(1.0, 1.0, 0.0)) { 
    ... 
    } 
} 

---

Se si desidera passare più espressioni contemporaneamente, è un po 'più complicato, ma è possibile scrivere un modello di espressione che agisce su operator, per raccogliere tutte le espressioni in un .

template<typename Derived> 
struct scoped_obj { 
    void enter() const { } 
    void leave() const { } 

    Derived const& get_obj() const { 
    return static_cast<Derived const&>(*this); 
    } 
}; 

template<typename L, typename R> struct collect 
    : scoped_obj< collect<L, R> > { 
    L l; 
    R r; 

    collect(L const& l, R const& r) 
    :l(l), r(r) { } 
    void enter() const { l.enter(); r.enter(); } 
    void leave() const { r.leave(); l.leave(); } 
}; 

template<typename D1, typename D2> 
collect<D1, D2> operator,(scoped_obj<D1> const& l, scoped_obj<D2> const& r) { 
    return collect<D1, D2>(l.get_obj(), r.get_obj()); 
} 

#define FOR_BLOCK(E) if(sbase const& _b_ = make_scont((E))) ; else 

È necessario ereditare l'oggetto Raii da scoped_obj<Class> come i seguenti spettacoli

struct GLTranslate : scoped_obj<GLTranslate> { 
    GLTranslate(float x, float y, float z) 
    :x(x),y(y),z(z) { } 

    void enter() const { 
    std::cout << "entering (" 
       << x << " " << y << " " << z << ")" 
       << std::endl; 
    } 

    void leave() const { 
    std::cout << "leaving (" 
       << x << " " << y << " " << z << ")" 
       << std::endl; 
    } 

    float x, y, z; 
}; 

int main() { 
    // if more than one element is passed, wrap them in parentheses 
    FOR_BLOCK((GLTranslate(10, 20, 30), GLTranslate(40, 50, 60))) { 
    std::cout << "in block..." << std::endl; 
    } 
} 

Tutte queste comportano non funzioni virtuali, e le funzioni coinvolte sono trasparenti al compilatore. Infatti, con la sopra GLTranslate cambiato per aggiungere un singolo intero a una variabile globale e quando si lascia sottrarre di nuovo, e il sotto definito GLTranslateE, ho fatto un test:

// we will change this and see how the compiler reacts. 
int j = 0; 

// only add, don't subtract again 
struct GLTranslateE : scoped_obj<GLTranslateE> { 
    GLTranslateE(int x):x(x) { } 

    void enter() const { 
    j += x; 
    } 

    int x; 
}; 

int main() { 
    FOR_BLOCK((GLTranslate(10), GLTranslateE(5))) { 
    /* empty */ 
    } 
    return j; 
} 

infatti, GCC a livello di ottimizzazione -O2 output this:

main: 
    sub  $29, $29, 8 
    ldw  $2, $0, j 
    add  $2, $2, 5 
    stw  $2, $0, j 
.L1: 
    add  $29, $29, 8 
    jr  $31 

Non me lo sarei aspettato, si è ottimizzato abbastanza bene!

Answer 3

Penso che sia ora possibile fare qualcosa del genere:

struct GlTranslate 
{ 
    operator()(double x,double y,double z, std::function<void()> f) 
    { 
     glPushMatrix(); glTranslatef(x, y, z); 
     f(); 
     glPopMatrix(); 
    } 
}; 

quindi nel codice

GlTranslate(x, y, z,[&]() 
{ 
// your code goes here 
}); 

Ovviamente, C++ 11 è necessario