为什么要调用dtor使用匿名/ lambda函数

如何解决为什么要调用dtor使用匿名/ lambda函数

| 我试图模仿一种最终的效果。所以我认为我应该进行快速的肮脏测试。这个想法是使用“最重要的” const来停止破坏，并将“ finally”块放入lambda中。但是显然我做错了什么，它在MyFinally（）的末尾被调用。我该如何解决这个问题？

#include <cassert>
template<typename T>
class D{
    T fn;
public:
    D(T v):fn(v){}
    ~D(){fn();}
};

template<typename T>
const D<T>& MyFinally(T t) { return D<T>(t); }

int d;
class A{
    int a;
public:
    void start(){
        int a=1;
        auto v = MyFinally([&]{a=2;});
        try{
            assert(a==1);
            //do stuff
        }
        catch(int){
            //do stuff
        }
    }
};
int main() {
    A a;
    a.start();
}

我的解决方案代码（注意：最终不能在同一块中包含两个。正如您所料。但是仍然有点脏）

#include <cassert>
template<typename T>
class D{
    T fn; bool exec;
public:
    D(T v):fn(v),exec(true){}
    //D(D const&)=delete //VS doesnt support this yet and i didnt feel like writing virtual=0
    D(D &&d):fn(move(d.fn)),exec(d.exec) {
      d.exec = false;
    }

    ~D(){if(exec) fn();}
};
template<typename T>
D<T> MyFinally(T t) { return D<T>(t); }


#define FINALLY(v) auto OnlyOneFinallyPlz = MyFinally(v)

int d;
class A{
public:
    int a;
    void start(){
        a=1;
        //auto v = MyFinally([&]{a=2;});
        FINALLY([&]{a=2;});
        try{
            assert(a==1);
            //do stuff
        }
        catch(int){
            FINALLY([&]{a=3;}); //ok,inside another scope
            try{
                assert(a==1);
                //do other stuff
            }
            catch(int){
                //do other stuff
            }
        }
    }
};
void main() {
    A a;
    a.start();
    assert(a.a==2);
}

有趣的是，如果您在原始代码中删除了MyFinally中的＆，它将起作用-_-。

解决方法

// WRONG! returning a reference to a temporary that will be
// destroyed at the end of the function!
template<typename T>
const D<T>& MyFinally(T t) { return D<T>(t); }

您可以通过引入move构造函数来修复它

template<typename T>
class D{
    T fn;
    bool exec;

public:
    D(T v):fn(move(v)),exec(true){}

    D(D &&d):fn(move(d.fn)),exec(d.exec) {
      d.exec = false;
    }

    ~D(){if(exec) fn();}
};

然后您可以重写玩具

template<typename T>
D<T> MyFinally(T t) { return D<T>(move(t)); }

希望能帮助到你。使用auto时，不需要\“ const reference \\”技巧。请参阅此处，了解如何在C ++ 03中使用const引用进行操作。 , 您的代码和Sutter \不相同。他的函数返回一个值，您的函数返回对一个对象的引用，该对象将在函数退出时销毁。调用代码中的const引用不维护该对象的生存期。 , 正如约翰尼斯所证明的那样，问题出在功能制造商的使用上。我认为您可以通过使用另一个C ++ 0x工具来避免该问题，即std::function。

class Defer
{
public:
  typedef std::function<void()> Executor;

  Defer(): _executor(DoNothing) {}

  Defer(Executor e): _executor(e) {}
  ~Defer() { _executor(); }

  Defer(Defer&& rhs): _executor(rhs._executor) {
    rhs._executor = DoNothing;
  }

  Defer& operator=(Defer rhs) {
    std::swap(_executor,rhs._executor);
    return *this;
  }

  Defer(Defer const&) = delete;

private:
  static void DoNothing() {}
  Executor _executor;
};

然后，您可以简单地使用它：

void A::start() {
  a = 1;
  Defer const defer([&]() { a = 2; });

  try { assert(a == 1); /**/ } catch(...) { /**/ }
}

, 好吧，这个问题已经由其他人解释了，所以我将提出一个解决办法，完全按照Herb Sutter编写他的代码的方式（顺便说一下，您的代码与他的代码不同）：首先，不要通过const引用返回：

template<typename T>
D<T> MyFinally(T t) 
{
   D<T> local(t); //create a local variable
   return local; 
}

然后将其写在呼叫站点：

const auto & v = MyFinally([&]{a=2;}); //store by const reference

这变得完全像Herb Sutter的代码一样。演示：http://www.ideone.com/uSkhP 现在，析构函数在退出start()函数之前被调用。另一种不再使用auto关键字的实现：

struct base { virtual ~base(){} };

template<typename TLambda>
struct exec : base 
{
   TLambda lambda;
   exec(TLambda l) : lambda(l){}
   ~exec() { lambda(); }
};

class lambda{
    base *pbase;
public:
    template<typename TLambda>
    lambda(TLambda l): pbase(new exec<TLambda>(l)){}
    ~lambda() { delete pbase; }
};

并将其用作：

lambda finally = [&]{a=2;  std::cout << \"finally executed\" << std::endl; };

看起来有趣吗？完整的演示：http://www.ideone.com/DYqrh , 您可以返回shared_ptr：

template<typename T>
std::shared_ptr<D<T>> MyFinally(T t) {
    return std::shared_ptr<D<T>>(new D<T>(t));
}

为什么要调用dtor使用匿名/ lambda函数

如何解决为什么要调用dtor使用匿名/ lambda函数

解决方法

相关推荐