Cómo no permitir provisionales

Para una clase Foo, ¿hay alguna manera de no permitir su construcción sin darle un nombre?

Por ejemplo:

Foo("hi");

¿Y solo permitirlo si le da un nombre, como el siguiente?

Foo my_foo("hi");

La vida útil del primero es solo la declaración y el segundo es el bloque adjunto. En mi caso de uso, Fooestá midiendo el tiempo entre el constructor y el destructor. Como nunca me refiero a la variable local, a menudo me olvido de ponerla y accidentalmente cambio la duración. En su lugar, me gustaría obtener un error de tiempo de compilación.

Otra solución basada en macros:

#define Foo class Foo

La declaración se Foo("hi");expande a class Foo("hi");, que está mal formada; pero se Foo a("hi")expande a lo class Foo a("hi")que es correcto.

Esto tiene la ventaja de que es compatible tanto con el código fuente como con el código binario existente (correcto). (Esta afirmación no es del todo correcta; consulte el comentario de Johannes Schaub y la discusión subsiguiente a continuación: "¿Cómo puede saber que es compatible con el código fuente existente? Su amigo incluye su encabezado y tiene void f () {int Foo = 0;} que anteriormente se compilaba bien y ahora se compila mal. Además, cada línea que define una función miembro de la clase Foo falla: void class Foo :: bar () {} " )

¿Qué tal un pequeño truco?

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

void Foo (float);


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

Haz que el constructor sea privado pero dale a la clase un método de creación .

Este no da como resultado un error del compilador, sino un error de tiempo de ejecución. En lugar de medir un tiempo incorrecto, obtiene una excepción que también puede ser aceptable.

Cualquier constructor que desee proteger necesita un argumento predeterminado en el que set(guard)se llama.

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

Las caracteristicas son:

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

El caso de f2, f3y el regreso de "hello"no estar querido. Para evitar que se arroje, puede permitir que la fuente de una copia sea temporal, restableciendo el guardpara protegernos ahora en lugar de la fuente de la copia. Ahora también verá por qué usamos los indicadores anteriores: nos permite ser flexibles.

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

Las características para f2, f3y por return "hello"ahora son siempre // OK.

Hace unos años escribí un parche para el compilador GNU C ++ que agrega una nueva opción de advertencia para esa situación. Esto se rastrea en un artículo de Bugzilla .

Desafortunadamente, GCC Bugzilla es un cementerio donde las sugerencias de características bien consideradas incluidas en el parche van a morir. :)

Esto fue motivado por el deseo de detectar exactamente el tipo de errores que son el tema de esta pregunta en un código que usa objetos locales como dispositivos para bloquear y desbloquear, medir el tiempo de ejecución, etc.

Tal como está, con su implementación, no puede hacer esto, pero puede usar esta regla a su favor:

Los objetos temporales no se pueden vincular a referencias no constantes

Puede mover el código de la clase a una función independiente que toma un parámetro de referencia no constante. Si lo hace, obtendrá un error del compilador si un temporal intenta vincularse a la referencia no constante.

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

Salida

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

Simplemente no tiene un constructor predeterminado y requiere una referencia a una instancia en cada constructor.

#include <iostream>
using namespace std;

enum SelfRef { selfRef };

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

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

No, me temo que esto no es posible. Pero podría obtener el mismo efecto creando una macro.

#define FOO(x) Foo _foo(x)

Con esto en su lugar, puede escribir FOO (x) en lugar de Foo my_foo (x).

Dado que el objetivo principal es prevenir errores, considere esto:

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
}

De esa manera no puede olvidarse de nombrar la variable y no puede olvidarse de escribir struct. Detallado, pero seguro.

Declare un constructor paramétrico como explícito y nadie jamás creará un objeto de esa clase sin querer.

Por ejemplo

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

void fun(const Foo&);

solo se puede usar de esta manera

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

pero nunca de esta manera (a través de un temporal en la pila)

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

Consulte también: Alexandrescu, Estándares de codificación C ++, artículo 40.