Comment interdire les temporaires

Pour une classe Foo, y a-t-il un moyen d'interdire sa construction sans lui donner un nom?

Par exemple:

Foo("hi");

Et ne l'autorisez que si vous lui donnez un nom, comme le suivant?

Foo my_foo("hi");

La durée de vie du premier n'est que la déclaration, et le second est le bloc englobant. Dans mon cas d'utilisation, Foomesure le temps entre le constructeur et le destructeur. Comme je ne fais jamais référence à la variable locale, j'oublie souvent de la mettre et je change accidentellement la durée de vie. Je voudrais plutôt obtenir une erreur de compilation.

Une autre solution macro-basée:

#define Foo class Foo

La déclaration Foo("hi");s'étend à class Foo("hi");, qui est mal formée; mais se Foo a("hi")développe class Foo a("hi"), ce qui est correct.

Cela présente l'avantage d'être à la fois compatible avec le code source et le code binaire existant (correct). (Cette affirmation n'est pas tout à fait correcte - veuillez consulter le commentaire de Johannes Schaub et la discussion qui s'ensuit ci-dessous: "Comment pouvez-vous savoir que la source est compatible avec le code existant? Son ami inclut son en-tête et a void f () {int Foo = 0;} qui précédemment compilé correctement et maintenant mal compilé! De plus, chaque ligne qui définit une fonction membre de la classe Foo échoue: void class Foo :: bar () {} " )

Que diriez-vous d'un petit hack

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

void Foo (float);


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

Rendez le constructeur privé mais donnez à la classe une méthode de création .

Celui-ci n'entraîne pas une erreur du compilateur, mais une erreur d'exécution. Au lieu de mesurer un mauvais moment, vous obtenez une exception qui peut également être acceptable.

Tout constructeur que vous souhaitez protéger a besoin d'un argument par défaut sur lequel set(guard)est appelé.

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

Les caractéristiques sont:

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

Le cas de f2, f3et le retour de "hello"ne pas être voulu. Pour éviter le rejet, vous pouvez autoriser la source d'une copie à être temporaire, en réinitialisant le guardpour nous garder maintenant au lieu de la source de la copie. Maintenant, vous voyez également pourquoi nous avons utilisé les pointeurs ci-dessus - cela nous permet d'être 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;
}; 

Les caractéristiques pour f2, f3et return "hello"sont maintenant toujours // OK.

Il y a quelques années, j'ai écrit un correctif pour le compilateur GNU C ++ qui ajoute une nouvelle option d'avertissement pour cette situation. Ceci est suivi dans un élément Bugzilla .

Malheureusement, GCC Bugzilla est un cimetière où les suggestions de fonctionnalités bien pensées incluses dans les correctifs vont mourir. :)

Cela a été motivé par le désir d'attraper exactement le genre de bogues qui font l'objet de cette question dans un code qui utilise des objets locaux comme gadgets pour verrouiller et déverrouiller, mesurer le temps d'exécution, etc.

En l'état, avec votre implémentation, vous ne pouvez pas faire cela, mais vous pouvez utiliser cette règle à votre avantage:

Les objets temporaires ne peuvent pas être liés à des références non const

Vous pouvez déplacer le code de la classe vers une fonction autonome qui prend un paramètre de référence non const. Si vous le faites, vous obtiendrez une erreur du compilateur si un temporaire tente de se lier à la référence non const.

Exemple de code

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

Production

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

Vous n'avez tout simplement pas de constructeur par défaut et vous avez besoin d'une référence à une instance dans chaque constructeur.

#include <iostream>
using namespace std;

enum SelfRef { selfRef };

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

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

Non, j'ai bien peur que ce ne soit pas possible. Mais vous pouvez obtenir le même effet en créant une macro.

#define FOO(x) Foo _foo(x)

Avec cela en place, vous pouvez simplement écrire FOO (x) au lieu de Foo my_foo (x).

Puisque l'objectif principal est d'éviter les bogues, considérez ceci:

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 cette façon, vous ne pouvez pas oublier de nommer la variable et vous ne pouvez pas oublier d'écrire struct. Verbose, mais sûr.

Déclarez un constructeur paramétrique comme explicite et personne ne créera jamais un objet de cette classe sans le vouloir.

Par exemple

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

void fun(const Foo&);

ne peut être utilisé que de cette façon

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

mais jamais de cette façon (via un temporaire sur la pile)

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

Voir aussi: Alexandrescu, C ++ Coding Standards, Item 40.