고유 이름을 생성하기 위해 C/C++ 매크로/템플릿 blackmagic

Question

매크로가 유효합니다. 템플릿이 좋습니다. 거의 모든 것이 제대로 작동합니다.

이 예는 OpenGL입니다. 그러나이 기술은 C++과 OpenGL에 대한 지식이 없기 때문에 가능합니다.

정확한 문제 :

원하는 표현식 E; 여기서 고유 한 이름을 지정할 필요가 없습니다. 즉 E가 정의 된 곳에서 생성자가 호출되고 블록 E가 끝나는 곳에서 소멸자가 호출됩니다.

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

수동 솔루션 :

예를 들어, 고려

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

지금, 나는 glTranslate에 대한뿐만 아니라이있다, 그러나 다른 PushAttrib/PopAttrib 많이도 호출합니다. 나는 각 var에 대해 고유 한 이름을 생각해 내지 않아도되는 것을 선호한다. 매크로 템플릿과 관련된 트릭이 있습니까? 아니면 자동으로 생성자가 정의 포인트에서 호출되는 변수를 생성하는 다른 것입니까? 블록의 끝에 호출 된 소멸자?

감사합니다.

Answer 1

컴파일러가 지원하는 경우 __COUNTER__ (아마 않습니다), 당신이 시도 할 수 :

// 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) 

{ 
    GL_TRANSLATE(1.0, 0.0, 0.0); 

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

} // auto popmatrix 

Answer 2

개인적으로는하지 않지만 고유 한 이름을 사용합니다. '

이

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

당신은 그 이름의 각각 별도의 범위에 있고 원

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

처럼 사용할 수 있습니다 : 당신이 그것을하고 싶은 경우에, 하나의 방법은 if 및 for의 조합을 사용하는 것입니다 갈등. 내부 이름은 외부 이름을 숨 깁니다. if 및 for 루프의 식은 상수이므로 컴파일러에서 쉽게 최적화해야합니다. 당신이 정말로 식을 전달하려는 경우

---

, 당신은 ScopedGuard 트릭 (Most Important const 참조)를 사용할 수 있지만 그것을 쓰기 위해 몇 가지 더 많은 작업이 필요합니다. 당신에게 지금

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; 
}; 

:

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 

그런 다음 적절한 enter 및 leave 기능을 제공 :하지만 좋은 측면은 우리가 for 루프 제거하기, 우리의 목적은 false으로 평가 할 수있다

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

---

: 사용자 측에 이름없이 완전히 쓸 수 있습니다

여러 표현식을 한꺼번에 전달하려는 경우 조금 더 까다 롭습니다. operator,에 적용되는 표현 템플릿을 작성하여 모든 표현식을 scont으로 수집 할 수 있습니다.

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 

는 다음 쇼

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; 
    } 
} 

모든 이들의 더 가상 함수를 포함하지 같은 scoped_obj<Class>에서 RAII 객체를 상속해야하고, 관련된 기능은 컴파일러에 투명합니다. 최적화 레벨 -O2에서 사실

// 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; 
} 

, GCC : 위의 GLTranslate 글로벌 변수에 하나의 정수를 추가로 변경하여 다시 빼서 떠날 때, 그리고 아래 GLTranslateE 정의 사실, 내가 테스트를했다

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

나는 그것을 아주 잘 최적화했다.

Answer 3

를 들어 내가 이런 식으로 뭔가 할 것이 가능하다고 생각 :

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

을

다음 코드 번호

분명히

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

6,, C++ (11)는 고유 한 이름을 생각하는 일부 복잡한 매크로 호출을 수행하는 것보다 어렵지 이유