Wie man Provisorien verbietet

Gibt es für eine Klasse Foo eine Möglichkeit, das Konstruieren zu verbieten, ohne ihr einen Namen zu geben?

Beispielsweise:

Foo("hi");

Und erlauben Sie es nur, wenn Sie ihm einen Namen geben, wie den folgenden?

Foo my_foo("hi");

Die Lebensdauer des ersten ist nur die Aussage, und die zweite ist der umschließende Block. In meinem Anwendungsfall Foowird die Zeit zwischen Konstruktor und Destruktor gemessen. Da ich mich nie auf die lokale Variable beziehe, vergesse ich oft, sie einzugeben, und ändere versehentlich die Lebensdauer. Ich möchte stattdessen einen Fehler bei der Kompilierung erhalten.

Eine weitere makrobasierte Lösung:

#define Foo class Foo

Die Aussage Foo("hi");erweitert sich zu class Foo("hi");, was schlecht geformt ist; aber Foo a("hi")erweitert sich class Foo a("hi"), was richtig ist.

Dies hat den Vorteil, dass es sowohl Quell- als auch Binärkompatibel mit vorhandenem (korrektem) Code ist. (Diese Behauptung ist nicht ganz richtig - siehe Johannes Schaubs Kommentar und die anschließende Diskussion unten: "Woher wissen Sie, dass die Quelle mit dem vorhandenen Code kompatibel ist? Sein Freund enthält seinen Header und hat void f () {int Foo = 0;} Die Zeile, die eine Elementfunktion der Klasse Foo definiert, schlägt fehl: void class Foo :: bar () {} " )

Wie wäre es mit einem kleinen Hack

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

void Foo (float);


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

Machen Sie den Konstruktor privat, aber geben Sie der Klasse eine Erstellungsmethode .

Dieser führt nicht zu einem Compilerfehler, sondern zu einem Laufzeitfehler. Anstatt eine falsche Zeit zu messen, erhalten Sie eine Ausnahme, die möglicherweise auch akzeptabel ist.

Jeder Konstruktor, den Sie schützen möchten, benötigt ein Standardargument, für das set(guard)aufgerufen wird.

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

Die Eigenschaften sind:

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

Der Fall f2, f3und die Rückkehr der "hello"nicht gewollt werden. Um ein Werfen zu verhindern, können Sie zulassen, dass die Quelle einer Kopie vorübergehend ist, indem Sie die Option " guardJetzt schützen" anstelle der Quelle der Kopie zurücksetzen . Jetzt sehen Sie auch, warum wir die obigen Zeiger verwendet haben - es ermöglicht uns, flexibel zu sein.

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

Die Eigenschaften für f2, f3und return "hello"sind jetzt immer // OK.

Vor einigen Jahren habe ich einen Patch für den GNU C ++ - Compiler geschrieben, der eine neue Warnoption für diese Situation hinzufügt. Dies wird in einem Bugzilla-Artikel verfolgt .

Leider ist GCC Bugzilla eine Grabstätte, auf der wohlüberlegte Vorschläge für Patch-Features sterben. :) :)

Dies wurde durch den Wunsch motiviert, genau die Art von Fehlern zu erkennen, die Gegenstand dieser Frage im Code sind, der lokale Objekte als Gadgets zum Sperren und Entsperren, Messen der Ausführungszeit usw. verwendet.

Bei Ihrer Implementierung können Sie dies nicht tun, aber Sie können diese Regel zu Ihrem Vorteil verwenden:

Temporäre Objekte können nicht an nicht konstante Referenzen gebunden werden

Sie können den Code aus der Klasse in eine freistehende Funktion verschieben, die einen nicht konstanten Referenzparameter verwendet. In diesem Fall wird ein Compilerfehler angezeigt, wenn ein temporärer Benutzer versucht, eine Bindung an die nicht konstante Referenz herzustellen.

Codebeispiel

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

Ausgabe

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

Sie haben einfach keinen Standardkonstruktor und benötigen in jedem Konstruktor einen Verweis auf eine Instanz.

#include <iostream>
using namespace std;

enum SelfRef { selfRef };

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

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

Nein, ich fürchte, das ist nicht möglich. Sie können jedoch den gleichen Effekt erzielen, indem Sie ein Makro erstellen.

#define FOO(x) Foo _foo(x)

Wenn dies vorhanden ist, können Sie einfach FOO (x) anstelle von Foo my_foo (x) schreiben.

Beachten Sie Folgendes, da das Hauptziel darin besteht, Fehler zu vermeiden:

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
}

Auf diese Weise können Sie nicht vergessen, die Variable zu benennen, und Sie können nicht vergessen, zu schreiben struct. Ausführlich, aber sicher.

Deklarieren Sie einen einparametrischen Konstruktor als explizit, und niemand wird jemals ungewollt ein Objekt dieser Klasse erstellen.

Beispielsweise

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

void fun(const Foo&);

kann nur so verwendet werden

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

aber niemals so (durch eine temporäre auf dem Stapel)

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

Siehe auch: Alexandrescu, C ++ Coding Standards, Punkt 40.