Question

这真是一个非常愚蠢的问题，答案可能是一个简单的“不”，但我会问，以防万一，因为它会很好。

我可以这样做，行为完全符合要求：

struct A { int x; };

A inc(A a) {
    a.x += 1;
    return a;
}

inc({ 1 });

{ 1 }是临时强制它不会被重用的事实，因为inc()使其无效（因为使用了移动构造函数 - 请更正我如果我错了！）。

但是如果我不记得{ 1 }应该代表的是什么，那么我为它做了一个变量，但我仍然想要强制要求它不能使用两次（我'我试图让它像一个临时的，但命名的）：

A a = { 1 };
inc(a);
inc(a);

a的引用类型没有变化会导致编译器抱怨双重使用 - 但a排除了移动构造函数不是临时的。

有解决方案吗？

Answer 1

我认为没有相应的数据类型，但您可以使用最小的嵌套块来限制变量的范围 - 我在代码中经常这样做：

{
  A a = { 1 };
  inc(a);
}
inc(a);  //error, `a` is not in scope

Answer 2

您几乎都在描述std::move的功能：

A a { 1 };
inc(std::move(a));

不，编译器不能强制执行单次使用：

A a { 1 };
for (int i = 0; i != 1000; ++i)
  if (g(i)) // Only signature is known, not runtime behavior.
     inc(std::move(a));

Answer 3

（可能）修复是声明inc专门采用右值参考：

A inc(A&& a)
{
    a.x += 1;
    return a;
}

使用左值调用它时，需要使用std::move显式移动它以进行编译：

A a = {1};
inc(a);    // Error: cannot bind lvalue to rvalue
inc(std::move(a));  // Ok

编译器不会抱怨双重使用，但是，（显式）使用std::move会使读取代码的任何人不再使用a。

Answer 4

你可以使用ref限定符，然后像这样使用它。

struct A
{
    A(int i): i_(i) {std::cout << "hello "<<i<<"\n"; }
    A inc() && {return A(++i_); }     //ref qualified incrementor. so it can be called only on temporaries. 
    friend int access( A a );    // to access the value
    A& operator=( const A& ) = delete;// don't allow copy
private :
    int i_;
};

int access( A a )
{
    return a.i_;
}

//用例

int main()
{
    //A a{5};    //this becomes useless. only use is to get the value..
    A b = A(10).inc();
    //b.inc();    //not possible
    //b = A( 12 ).inc();    //not possible
    std::cout << "\n val = "<<access( b );
return 0;
}

但这会使您的结构成为非POD。

这也适用于gcc＆gt; 4.8.1。

Answer 5

可以检测到对象在运行时被用作临时对象。

this是Mozilla实现它的方式

从上面链接复制。您可以在git repo中搜索MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER，例如用法

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/* Implementation of macros to ensure correct use of RAII Auto* objects. */

#ifndef mozilla_GuardObjects_h
#define mozilla_GuardObjects_h

#include "mozilla/Assertions.h"
#include "mozilla/NullPtr.h"
#include "mozilla/Types.h"

#ifdef __cplusplus

#ifdef DEBUG

namespace mozilla {
namespace detail {

/*
 * The following classes are designed to cause assertions to detect
 * inadvertent use of guard objects as temporaries. In other words,
 * when we have a guard object whose only purpose is its constructor and
 * destructor (and is never otherwise referenced), the intended use
 * might be:
 *
 *   AutoRestore savePainting(mIsPainting);
 *
 * but is is easy to accidentally write:
 *
 *   AutoRestore(mIsPainting);
 *
 * which compiles just fine, but runs the destructor well before the
 * intended time.
 *
 * They work by adding (#ifdef DEBUG) an additional parameter to the
 * guard object's constructor, with a default value, so that users of
 * the guard object's API do not need to do anything. The default value
 * of this parameter is a temporary object. C++ (ISO/IEC 14882:1998),
 * section 12.2 [class.temporary], clauses 4 and 5 seem to assume a
 * guarantee that temporaries are destroyed in the reverse of their
 * construction order, but I actually can't find a statement that that
 * is true in the general case (beyond the two specific cases mentioned
 * there). However, it seems to be true.
 *
 * These classes are intended to be used only via the macros immediately
 * below them:
 *
 *   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER declares (ifdef DEBUG) a member
 *     variable, and should be put where a declaration of a private
 *     member variable would be placed.
 *   MOZ_GUARD_OBJECT_NOTIFIER_PARAM should be placed at the end of the
 *     parameters to each constructor of the guard object; it declares
 *     (ifdef DEBUG) an additional parameter. (But use the *_ONLY_PARAM
 *     variant for constructors that take no other parameters.)
 *   MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL should likewise be used in
 *     the implementation of such constructors when they are not inline.
 *   MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT should be used in
 *     the implementation of such constructors to pass the parameter to
 *     a base class that also uses these macros
 *   MOZ_GUARD_OBJECT_NOTIFIER_INIT is a statement that belongs in each
 *     constructor. It uses the parameter declared by
 *     MOZ_GUARD_OBJECT_NOTIFIER_PARAM.
 *
 * For more details, and examples of using these macros, see
 * https://developer.mozilla.org/en/Using_RAII_classes_in_Mozilla
 */
class MOZ_EXPORT GuardObjectNotifier
{
  private:
    bool* statementDone;

  public:
    GuardObjectNotifier() : statementDone(nullptr) { }

    ~GuardObjectNotifier() {
      *statementDone = true;
    }

    void setStatementDone(bool* statementIsDone) {
      statementDone = statementIsDone;
    }
};

class MOZ_EXPORT GuardObjectNotificationReceiver
{
  private:
    bool statementDone;

  public:
    GuardObjectNotificationReceiver() : statementDone(false) { }

    ~GuardObjectNotificationReceiver() {
      /*
       * Assert that the guard object was not used as a temporary.  (Note that
       * this assert might also fire if init is not called because the guard
       * object's implementation is not using the above macros correctly.)
       */
      MOZ_ASSERT(statementDone);
    }

    void init(const GuardObjectNotifier& constNotifier) {
      /*
       * constNotifier is passed as a const reference so that we can pass a
       * temporary, but we really intend it as non-const.
       */
      GuardObjectNotifier& notifier = const_cast<GuardObjectNotifier&>(constNotifier);
      notifier.setStatementDone(&statementDone);
    }
};

} /* namespace detail */
} /* namespace mozilla */

#endif /* DEBUG */

#ifdef DEBUG
#  define MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER \
     mozilla::detail::GuardObjectNotificationReceiver _mCheckNotUsedAsTemporary;
#  define MOZ_GUARD_OBJECT_NOTIFIER_PARAM \
     , const mozilla::detail::GuardObjectNotifier& _notifier = \
         mozilla::detail::GuardObjectNotifier()
#  define MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM \
     const mozilla::detail::GuardObjectNotifier& _notifier = \
         mozilla::detail::GuardObjectNotifier()
#  define MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL \
     , const mozilla::detail::GuardObjectNotifier& _notifier
#  define MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_IN_IMPL \
     const mozilla::detail::GuardObjectNotifier& _notifier
#  define MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT \
     , _notifier
#  define MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_TO_PARENT \
       _notifier
#  define MOZ_GUARD_OBJECT_NOTIFIER_INIT \
     do { _mCheckNotUsedAsTemporary.init(_notifier); } while (0)
#else
#  define MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
#  define MOZ_GUARD_OBJECT_NOTIFIER_PARAM
#  define MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM
#  define MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL
#  define MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_IN_IMPL
#  define MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_TO_PARENT
#  define MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT
#  define MOZ_GUARD_OBJECT_NOTIFIER_INIT do { } while (0)
#endif

#endif /* __cplusplus */

#endif /* mozilla_GuardObjects_h */

是否存在模仿临时的C ++变量类型？

5 个答案: