44

宏很好。模板很好。几乎任何工作都很好。

例子是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 想出一个唯一的名称。是否有一些涉及宏模板的技巧......或者其他会自动创建一个变量的东西，该变量的构造函数在定义点被调用；并在块结束时调用析构函数？

谢谢！

4

4 回答 4

67

我不会亲自这样做，而只是想出独特的名字。但是，如果您想这样做，一种方法是使用ifand的组合for：

#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)) {
    ...
  }
}

这些名称中的每一个都在不同的范围内，不会发生冲突。内部名称隐藏外部名称。ifand循环中的表达式for是常量，编译器应该很容易优化。

如果你真的想传递一个表达式，你可以使用 ScopedGuard 技巧（见最重要const的），但它需要更多的工作来编写它。但好的一面是，我们可以摆脱for循环，让我们的对象评估为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

然后，您提供正确的enter和leave功能：

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

现在，您可以在用户端完全不用名称来编写它：

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

您需要继承 RAII 对象，scoped_obj<Class>如下所示

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

所有这些都不涉及虚函数，所涉及的函数对编译器是透明的。实际上，将上面的GLTranslate内容更改为将单个整数添加到全局变量中，然后再次减去它，以及下面定义的GLTranslateE内容，我做了一个测试：

// 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 会-O2输出以下内容：

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

我没想到，它优化得很好！

于 2010-03-10T19:04:07.333 回答
39

如果您的编译器支持__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
于 2010-03-10T19:04:59.250 回答
11

我认为现在可以做这样的事情：

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

显然，需要C++11

于 2013-06-24T16:56:28.967 回答
0

一个答案中描述的规范方法是使用 lambda 表达式作为块，在 C++ 中，您可以轻松编写模板函数

with<T>(T instance, const std::function<void(T)> &f) {
    f(instance);
}

并像使用它一样

with(GLTranslate(...), [] (auto translate) {
    ....
});

但是想要一种机制来避免在您的范围内定义名称的最常见原因是做很多事情的长函数/方法。如果此类问题一直困扰着您，您可以尝试使用非常短的方法/函数来进行现代 OOP/简洁代码风格的更改

于 2019-06-09T07:57:34.417 回答