Come vietare i provvisori

Per una classe Foo, c'è un modo per impedirne la costruzione senza dargli un nome?

Per esempio:

Foo("hi");

E lo consenti solo se gli dai un nome, come il seguente?

Foo my_foo("hi");

La durata del primo è solo l'affermazione e la seconda è il blocco che lo racchiude. Nel mio caso d'uso, Foomisura il tempo tra il costruttore e il distruttore. Dato che non mi riferisco mai alla variabile locale, spesso dimentico di inserirla e cambio accidentalmente la durata. Vorrei invece ricevere un errore in fase di compilazione.

Un'altra soluzione basata su macro:

#define Foo class Foo

L'affermazione si Foo("hi");espande a class Foo("hi");, che è mal formata; ma si Foo a("hi")espande in class Foo a("hi"), il che è corretto.

Questo ha il vantaggio di essere compatibile sia dal codice sorgente che dal binario con il codice esistente (corretto). (Questa affermazione non è del tutto corretta - si prega di vedere il commento di Johannes Schaub e la successiva discussione di seguito: "Come puoi sapere che è compatibile con il codice esistente? Il suo amico include la sua intestazione e ha void f () {int Foo = 0;} che in precedenza veniva compilato correttamente e ora viene compilato male! Inoltre, ogni riga che definisce una funzione membro della classe Foo fallisce: void class Foo :: bar () {} " )

Che ne dici di un piccolo trucco

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

void Foo (float);


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

Rendi privato il costruttore ma dai alla classe un metodo create .

Questo non si traduce in un errore del compilatore, ma in un errore di runtime. Invece di misurare un tempo sbagliato, ottieni un'eccezione che potrebbe essere anche accettabile.

Qualsiasi costruttore che si desidera proteggere necessita di un argomento predefinito su cui set(guard)viene chiamato.

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

Le caratteristiche sono:

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

Il caso f2, f3e il ritorno di "hello"non essere voluto. Per evitare il lancio, puoi consentire che l'origine di una copia sia temporanea, reimpostando il guardper proteggerci ora anziché l'origine della copia. Ora capisci anche perché abbiamo usato i puntatori sopra: ci consentono di essere flessibili.

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

Le caratteristiche per f2, f3e per return "hello"ora sono sempre // OK.

Qualche anno fa ho scritto una patch per il compilatore GNU C ++ che aggiunge una nuova opzione di avviso per quella situazione. Questo è tracciato in un oggetto Bugzilla .

Sfortunatamente, GCC Bugzilla è un cimitero dove i suggerimenti sulle funzionalità incluse nelle patch ben ponderate vanno a morire. :)

Ciò è stato motivato dal desiderio di cogliere esattamente il tipo di bug oggetto di questa domanda in un codice che utilizza oggetti locali come gadget per il blocco e lo sblocco, la misurazione del tempo di esecuzione e così via.

Così com'è, con la tua implementazione, non puoi farlo, ma puoi usare questa regola a tuo vantaggio:

Gli oggetti temporanei non possono essere associati a riferimenti non costanti

È possibile spostare il codice dalla classe a una funzione indipendente che accetta un parametro di riferimento non const. Se lo fai, riceverai un errore del compilatore se un temporaneo tenta di collegarsi al riferimento non const.

Esempio di codice

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

Produzione

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

Semplicemente non hai un costruttore predefinito e richiede un riferimento a un'istanza in ogni costruttore.

#include <iostream>
using namespace std;

enum SelfRef { selfRef };

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

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

No, temo che non sia possibile. Ma potresti ottenere lo stesso effetto creando una macro.

#define FOO(x) Foo _foo(x)

Con questo a posto, puoi semplicemente scrivere FOO (x) invece di Foo my_foo (x).

Poiché l'obiettivo principale è prevenire i bug, considera questo:

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
}

In questo modo non puoi dimenticare di nominare la variabile e non puoi dimenticare di scrivere struct. Verboso, ma sicuro.

Dichiara il costruttore uniparametrico come esplicito e nessuno creerà mai un oggetto di quella classe involontariamente.

Per esempio

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

void fun(const Foo&);

può essere utilizzato solo in questo modo

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

ma mai in questo modo (tramite un temporaneo in pila)

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

Vedi anche: Alexandrescu, C ++ Coding Standards, Item 40.