Jak zabronić używania tymczasowych

Czy w przypadku klasy Foo istnieje sposób, aby zabronić jej tworzenia bez nadawania jej nazwy?

Na przykład:

Foo("hi");

I zezwolić na to tylko wtedy, gdy nadasz mu nazwę, taką jak ta?

Foo my_foo("hi");

Czas życia pierwszego to tylko instrukcja, a drugi to otaczający blok. W moim przypadku Foojest to pomiar czasu między konstruktorem a destruktorem. Ponieważ nigdy nie odwołuję się do zmiennej lokalnej, często zapominam o jej wstawieniu i przypadkowo zmieniam czas życia. Chciałbym zamiast tego otrzymać błąd czasu kompilacji.

Inne rozwiązanie oparte na makrach:

#define Foo class Foo

Oświadczenie Foo("hi");rozszerza się do class Foo("hi");, które jest źle sformułowane; ale Foo a("hi")rozszerza się class Foo a("hi"), co jest poprawne.

Ma to tę zaletę, że jest zgodny zarówno z kodem źródłowym, jak i binarnym z istniejącym (poprawnym) kodem. (To twierdzenie nie jest całkowicie poprawne - zobacz komentarz Johannesa Schauba i następującą dyskusję poniżej: „Skąd możesz wiedzieć, że jest on zgodny z istniejącym kodem? Jego przyjaciel zawiera swój nagłówek i ma void f () {int Foo = 0;} który wcześniej dobrze się skompilował, a teraz źle się kompiluje! Ponadto każda linia definiująca funkcję składową klasy Foo kończy się niepowodzeniem: void class Foo :: bar () {} " )

Co powiesz na mały hack

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

void Foo (float);


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

Ustaw konstruktor jako prywatny, ale nadaj klasie metodę tworzenia .

Ten nie powoduje błędu kompilatora, ale błąd wykonania. Zamiast mierzyć niewłaściwy czas, otrzymujesz wyjątek, który również może być akceptowalny.

Każdy konstruktor, którego chcesz chronić, potrzebuje domyślnego argumentu, który set(guard)jest wywoływany.

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

Cechy charakterystyczne to:

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

Przypadek f2, f3a powrót "hello"nie może być chciał. Aby zapobiec rzucaniu, możesz pozwolić, aby źródło kopii było tymczasowe, resetując, guardaby teraz chroniło nas zamiast źródła kopii. Teraz widzisz również, dlaczego użyliśmy powyższych wskaźników - pozwala nam to być elastycznym.

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

Cechy charakterystyczne dla f2, f3i return "hello"są teraz zawsze // OK.

Kilka lat temu napisałem łatkę dla kompilatora GNU C ++, która dodaje nową opcję ostrzeżenia o takiej sytuacji. Jest to śledzone w elemencie Bugzilli .

Niestety GCC Bugzilla to cmentarzysko, w którym dobrze przemyślane sugestie dotyczące funkcji zawartych w łatkach umierają. :)

Było to motywowane chęcią wyłapania dokładnie tego rodzaju błędów, które są przedmiotem tego pytania, w kodzie, który wykorzystuje lokalne obiekty jako gadżety do blokowania i odblokowywania, mierzenia czasu wykonania i tak dalej.

W przypadku Twojej implementacji nie możesz tego zrobić, ale możesz użyć tej reguły na swoją korzyść:

Obiekty tymczasowe nie mogą być powiązane z odniesieniami innymi niż stałe

Możesz przenieść kod z klasy do wolnostojącej funkcji, która przyjmuje parametr odniesienia inny niż const. Jeśli to zrobisz, otrzymasz błąd kompilatora, jeśli tymczasowy spróbuje powiązać się z odwołaniem innym niż const.

Przykład kodu

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

Wynik

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

Po prostu nie mają domyślnego konstruktora i wymagają odwołania do wystąpienia w każdym konstruktorze.

#include <iostream>
using namespace std;

enum SelfRef { selfRef };

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

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

Nie, obawiam się, że to niemożliwe. Ale możesz uzyskać ten sam efekt, tworząc makro.

#define FOO(x) Foo _foo(x)

Mając to na miejscu, możesz po prostu napisać FOO (x) zamiast Foo my_foo (x).

Ponieważ głównym celem jest zapobieganie błędom, rozważ to:

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
}

W ten sposób nie możesz zapomnieć o nazwie zmiennej i nie możesz zapomnieć o napisaniu struct. Szczegółowy, ale bezpieczny.

Zadeklaruj jednoparametryczny konstruktor jako jawny i nikt nigdy nie utworzy przypadkowo obiektu tej klasy.

Na przykład

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

void fun(const Foo&);

można używać tylko w ten sposób

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

ale nigdy w ten sposób (przez tymczasowe na stosie)

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

Zobacz też: Alexandrescu, Standardy kodowania C ++, pozycja 40.