Re: Defeating (N)RVO

#include <stdlib.h>
#include <algorithm>
#include <iostream>

template <typename RetType>
struct cheater {
private:
    RetType value_;
    int* refCnt_;
    mutable bool hasRead_;

    void swap(cheater& other) {
        std::swap(value_, other.value_);
        std::swap(refCnt_, other.refCnt_);
        std::swap(hasRead_, other.hasRead_);
    }

public:
    cheater(RetType result) :
      value_(result), refCnt_(new int(1)), hasRead_(false)
    {
    }

    cheater(const cheater& src) :
      value_(src.value_), refCnt_(src.refCnt_), hasRead_(src.hasRead_)
    {
      ++*refCnt_;
    }

    cheater& operator=(const cheater& src)
    {
      cheater(src).swap(*this);
      return *this;
    }

    ~cheater()
    {
      if (--*refCnt_ == 0) {
          delete refCnt_;
          if (!hasRead_) {
              abort();
          }
      }
    }

    operator RetType() const {
        hasRead_ = true;
        return value_;
    }
};