如何禁止临时工

另一个基于宏的解决方案：

#define Foo class Foo

语句Foo("hi");扩展到class Foo("hi");，该语句形成不佳；但是Foo a("hi")扩展到class Foo a("hi")，这是正确的。

这具有与现有（正确的）代码相符的源和二进制兼容的优势。（这一说法并不完全正确 - 请参阅Johannes Schaub的评论并随后的讨论："您怎么知道它与现有代码兼容？他的朋友包括他的标题，并具有void F（）{int foo = 0;}先前已经编译了且现在更加密码！另外，定义类foo的成员函数失败的每一行都会失败：void class foo :: bar（）{} {}" ））

一个小hack

class Foo
{
    public:
        Foo (const char*) {}
};
void Foo (float);

int main ()
{
    Foo ("hello"); // error
    class Foo a("hi"); // OK
    return 1;
}

将构造函数私有化，但给出了类A create 方法。

这不会导致编译器错误，而是运行时错误。您没有测量错误的时间，而是会得到一个例外，这也可能是可以接受的。

您要守卫的任何构造函数都需要默认参数，以便在哪个 set(guard)上称为。

struct Guard {
  Guard()
    :guardflagp()
  { }
  ~Guard() {
    assert(guardflagp && "Forgot to call guard?");
    *guardflagp = 0;
  }
  void *set(Guard const *&guardflag) {
    if(guardflagp) {
      *guardflagp = 0;
    }
    guardflagp = &guardflag;
    *guardflagp = this;
  }
private:
  Guard const **guardflagp;
};
class Foo {
public:
  Foo(const char *arg1, Guard &&g = Guard()) 
    :guard()
  { g.set(guard); }
  ~Foo() {
    assert(!guard && "A Foo object cannot be temporary!");
  }
private:
  mutable Guard const *guard;
}; 

特征是：

Foo f() {
  // OK (no temporary)
  Foo f1("hello");
  // may throw (may introduce a temporary on behalf of the compiler)
  Foo f2 = "hello";
  // may throw (introduces a temporary that may be optimized away
  Foo f3 = Foo("hello");
  // OK (no temporary)
  Foo f4{"hello"};
  // OK (no temporary)
  Foo f = { "hello" };
  // always throws
  Foo("hello");
  // OK (normal copy)
  return f;
  // may throw (may introduce a temporary on behalf of the compiler)
  return "hello";
  // OK (initialized temporary lives longer than its initializers)
  return { "hello" };
}
int main() {
  // OK (it's f that created the temporary in its body)
  f();
  // OK (normal copy)
  Foo g1(f());
  // OK (normal copy)
  Foo g2 = f();
}

不需要f2，f3的情况和"hello"的返回。为了防止投掷，您可以通过重置guard来保护我们而不是副本的来源来允许副本的源为临时。现在，您还明白了为什么我们使用了上面的指针 - 它使我们能够灵活。

class Foo {
public:
  Foo(const char *arg1, Guard &&g = Guard()) 
    :guard()
  { g.set(guard); }
  Foo(Foo &&other)
    :guard(other.guard)
  {
    if(guard) {
      guard->set(guard);
    }
  }
  Foo(const Foo& other)
    :guard(other.guard)
  {
    if(guard) {
      guard->set(guard);
    }
  }
  ~Foo() {
    assert(!guard && "A Foo object cannot be temporary!");
  }
private:
  mutable Guard const *guard;
}; 

f2，f3和return "hello"的特征始终是// OK。

几年前，我为GNU C 编译器编写了一个补丁，该补丁为这种情况添加了一个新的警告选项。这是在Bugzilla项目中跟踪的。

不幸的是，GCC Bugzilla是一个墓地，其中包含良好的补丁功能建议将死亡。：）

这是出于渴望准确地捕获该问题的错误的愿望，这些错误是代码中使用本地对象作为锁定和解锁的小工具，测量执行时间等等的。

class Foo
{
    public:
        Foo(const char* ){}
        friend void InitMethod(Foo& obj);
};
void InitMethod(Foo& obj){}
int main()
{
    Foo myVar("InitMe");
    InitMethod(myVar);    //Works
    InitMethod("InitMe"); //Does not work  
    return 0;
}

prog.cpp: In function ‘int main()’:
prog.cpp:13: error: invalid initialization of non-const reference of type ‘Foo&’ from a temporary of type ‘const char*’
prog.cpp:7: error: in passing argument 1 of ‘void InitMethod(Foo&)’

#include <iostream>
using namespace std;
enum SelfRef { selfRef };
struct S
{
    S( SelfRef, S const & ) {}
};
int main()
{
    S a( selfRef, a );
}

#define FOO(x) Foo _foo(x)

struct Foo
{
  Foo( const char* ) { /* ... */ }
};
enum { Foo };
int main()
{
  struct Foo foo( "hi" ); // OK
  struct Foo( "hi" ); // fail
  Foo foo( "hi" ); // fail
  Foo( "hi" ); // fail
}

class Foo
{
public: 
  explicit Foo(const char*);
};
void fun(const Foo&);

void g() {
  Foo a("text");
  fun(a);
}

void g() {
  fun("text");
}