Como proibir temporários

Para uma classe Foo, existe uma maneira de proibir sua construção sem dar a ela um nome?

Por exemplo:

Foo("hi");

E só permite se você der um nome, como o seguinte?

Foo my_foo("hi");

O tempo de vida do primeiro é apenas a instrução e o segundo é o bloco envolvente. No meu caso de uso, Fooé medir o tempo entre o construtor e o destruidor. Como nunca me refiro à variável local, frequentemente esqueço de inseri-la e, acidentalmente, mudo o tempo de vida. Eu gostaria de obter um erro de tempo de compilação.

Outra solução baseada em macro:

#define Foo class Foo

A declaração se Foo("hi");expande para class Foo("hi");, que está malformada; mas se Foo a("hi")expande para class Foo a("hi"), o que é correto.

Isso tem a vantagem de ser compatível com o código-fonte e o binário com o código existente (correto). (Esta afirmação não está totalmente correta - consulte o comentário de Johannes Schaub e a discussão subsequente abaixo: "Como você pode saber se o código-fonte é compatível com o código existente? Seu amigo inclui seu cabeçalho e tem void f () {int Foo = 0;} que anteriormente compilava bem e agora compila incorretamente! Além disso, cada linha que define uma função de membro da classe Foo falha: void class Foo :: bar () {} " )

Que tal um pequeno hack

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

void Foo (float);


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

Torne o construtor privado, mas dê à classe um método de criação .

Este não resulta em um erro do compilador, mas um erro de tempo de execução. Em vez de medir um tempo errado, você obtém uma exceção que também pode ser aceitável.

Qualquer construtor que você deseja proteger precisa de um argumento padrão no qual set(guard)é chamado.

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

As características são:

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

O caso de f2, f3eo retorno de "hello"não ser querido. Para evitar o lançamento, você pode permitir que a origem de uma cópia seja temporária, redefinindo o guardpara agora nos proteger em vez da origem da cópia. Agora você também vê porque usamos as dicas acima - isso nos permite ser flexíveis.

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

As características para f2, f3e para return "hello"agora são sempre // OK.

Alguns anos atrás, escrevi um patch para o compilador GNU C ++ que adiciona uma nova opção de aviso para essa situação. Isso é rastreado em um item do Bugzilla .

Infelizmente, o GCC Bugzilla é um cemitério onde sugestões de recursos bem consideradas com patch incluído vão morrer. :)

Isso foi motivado pelo desejo de detectar exatamente o tipo de bugs que são o assunto desta questão no código que usa objetos locais como dispositivos para bloquear e desbloquear, medir o tempo de execução e assim por diante.

Como está, com sua implementação, você não pode fazer isso, mas pode usar esta regra a seu favor:

Objetos temporários não podem ser vinculados a referências não constantes

Você pode mover o código da classe para uma função independente que usa um parâmetro de referência não const. Se você fizer isso, obterá um erro do compilador se um temporário tentar se vincular à referência não const.

Amostra de Código

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

Resultado

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&)’

Simplesmente não tem um construtor padrão e exige uma referência a uma instância em cada construtor.

#include <iostream>
using namespace std;

enum SelfRef { selfRef };

struct S
{
    S( SelfRef, S const & ) {}
};

int main()
{
    S a( selfRef, a );
}

Não, infelizmente isso não é possível. Mas você pode obter o mesmo efeito criando uma macro.

#define FOO(x) Foo _foo(x)

Com isso no lugar, você pode simplesmente escrever FOO (x) em vez de Foo my_foo (x).

Como o objetivo principal é evitar bugs, considere o seguinte:

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
}

Dessa forma, você não pode esquecer de nomear a variável e não pode se esquecer de escrever struct. Detalhado, mas seguro.

Declare um construtor paramétrico como explícito e ninguém jamais criará um objeto dessa classe acidentalmente.

Por exemplo

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

void fun(const Foo&);

só pode ser usado desta forma

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

mas nunca desta forma (através de um temporário na pilha)

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

Veja também: Alexandrescu, C ++ Coding Standards, Item 40.