Quand puis-je utiliser une déclaration anticipée?

Mettez-vous dans le compilateur de position: lorsque vous transférez déclarer un type, tout le compilateur sait, c'est que ce type existe; il ne sait rien au sujet de sa taille, les membres ou les méthodes. C'est pourquoi il est appelé un de type incomplète. Par conséquent, vous ne pouvez pas utiliser le type de déclarer un membre, ou d'une classe de base, puisque le compilateur aurait besoin de savoir la mise en page de ce type.

En supposant que le terme suivantes déclaration.

class X;

Voici ce que vous pouvez faire et ne pas faire.

Ce que vous pouvez faire avec un type incomplète:

• Déclarer un membre d'un pointeur ou d'une référence à la nature incomplète de type:

  class Foo {
      X *p;
      X &r;
  };

• Déclarer des méthodes ou des fonctions qui acceptent/retour incomplet types:

  void f1(X);
  X    f2();

• Définir des méthodes ou des fonctions qui acceptent de rendement/pointeurs/références pour le type incomplète (mais sans l'aide de ses membres):

  void f3(X*, X&) {}
  X&   f4()       {}
  X*   f5()       {}

Ce que vous ne pouvez pas faire avec un type incomplète:

• L'utiliser comme une classe de base

  class Foo : X {} //compiler error!

• L'utiliser pour déclarer un membre:

  class Foo {
      X m; //compiler error!
  };

• Définir des méthodes ou des fonctions à l'aide de ce type

  void f1(X x) {} //compiler error!
  X    f2()    {} //compiler error!

• Utiliser ses méthodes ou des champs, en fait en essayant de déréférencer une variable de type incomplète

  class Foo {
      X *m;            
      void method()            
      {
          m->someMethod();      //compiler error!
          int i = m->someField; //compiler error!
      }
  };

---

Quand il s'agit de modèles, il n'y a pas de règle absolue: si vous pouvez utiliser un type incomplète comme un paramètre du modèle dépend de la façon dont le type est utilisé dans le modèle.

Par exemple, std::vector<T> exige de ses paramètre pour être complet, tandis que le boost::container::vector<T> ne le fait pas. Parfois, un type est nécessaire que si vous utilisez certaines fonctions de membre; c'est le cas pour std::unique_ptr<T>, par exemple.

Bien documentée modèle doit indiquer dans sa documentation à toutes les exigences de ses paramètres, y compris la nécessité de compléter les types ou pas.

Lakos distingue entre la classe d'utilisation

1. dans-nom-seulement (pour lesquels une déclaration anticipée est suffisant) et
2. en taille (pour qui la définition de la classe est nécessaire).

Je ne l'ai jamais vu prononcée de façon plus succincte 🙂

Aucune réponse jusqu'à présent décrire quand on peut utiliser une déclaration anticipée d'un modèle de classe. Donc, ici il va.

Un modèle de classe peuvent être transmises, a déclaré que:

template <typename> struct X;

En suivant la structure de la accepté de répondre à,

Voici ce que vous pouvez faire et ne pas faire.

Ce que vous pouvez faire avec un type incomplète:

• Déclarer un membre d'un pointeur ou d'une référence à la nature incomplète de type dans un autre modèle de classe:

  template <typename T>
  class Foo {
      X<T>* ptr;
      X<T>& ref;
  };

• Déclarer un membre à un pointeur ou une référence à l'un de ses incomplète instanciations:

  class Foo {
      X<int>* ptr;
      X<int>& ref;
  };

• Déclarer les modèles de fonction ou fonction membre modèles qui acceptent/retour incomplet types:

  template <typename T>
     void      f1(X<T>);
  template <typename T>
     X<T>    f2();

• De déclarer des fonctions ou des fonctions membres qui acceptent/retour de l'un de ses incomplète instanciations:

  void      f1(X<int>);
  X<int>    f2();

• Définir les modèles de fonction ou fonction membre modèles qui acceptent de rendement/pointeurs/références pour le type incomplète (mais sans l'aide de ses membres):

  template <typename T>
     void      f3(X<T>*, X<T>&) {}
  template <typename T>
     X<T>&   f4(X<T>& in) { return in; }
  template <typename T>
     X<T>*   f5(X<T>* in) { return in; }

• Définir des méthodes ou des fonctions qui acceptent de rendement/pointeurs/références pour l'un de ses incomplète instanciations (mais sans l'aide de ses membres):

  void      f3(X<int>*, X<int>&) {}
  X<int>&   f4(X<int>& in) { return in; }
  X<int>*   f5(X<int>* in) { return in; }

• L'utiliser comme une classe de base d'un autre modèle de classe

  template <typename T>
  class Foo : X<T> {} //OK as long as X is defined before
                      //Foo is instantiated.
  
  Foo<int> a1; //Compiler error.
  
  template <typename T> struct X {};
  Foo<int> a2; //OK since X is now defined.

• L'utiliser pour déclarer un membre d'un autre modèle de classe:

  template <typename T>
  class Foo {
      X<T> m; //OK as long as X is defined before
              //Foo is instantiated. 
  };
  
  Foo<int> a1; //Compiler error.
  
  template <typename T> struct X {};
  Foo<int> a2; //OK since X is now defined.

• Définir les modèles de fonction ou de méthodes à l'aide de ce type

  template <typename T>
    void    f1(X<T> x) {}    //OK if X is defined before calling f1
  template <typename T>
    X<T>    f2(){return X<T>(); }  //OK if X is defined before calling f2
  
  void test1()
  {
     f1(X<int>());  //Compiler error
     f2<int>();     //Compiler error
  }
  
  template <typename T> struct X {};
  
  void test2()
  {
     f1(X<int>());  //OK since X is defined now
     f2<int>();     //OK since X is defined now
  }

Ce que vous ne pouvez pas faire avec un type incomplète:

• Utiliser l'un de ses instanciations comme une classe de base

  class Foo : X<int> {} //compiler error!

• Utiliser l'un de ses instanciations de déclarer un membre:

  class Foo {
      X<int> m; //compiler error!
  };

• Définir des méthodes ou des fonctions à l'aide de l'un de ses instanciations

  void      f1(X<int> x) {}            //compiler error!
  X<int>    f2() {return X<int>(); }   //compiler error!

• Utiliser les méthodes ou des domaines de l'une de ses instanciations, en fait en essayant de déréférencer une variable de type incomplète

  class Foo {
      X<int>* m;            
      void method()            
      {
          m->someMethod();      //compiler error!
          int i = m->someField; //compiler error!
      }
  };

• Créer explicite les instanciations de la classe de modèle

  template struct X<int>;

Je suis en train d'écrire cela comme une réponse distincte plutôt que juste un commentaire parce que je suis en désaccord avec Luc Touraille réponse, pas sur le terrain de la légalité, mais pour les logiciels robustes et le risque d'interprétation erronée.

Précisément, j'ai un problème avec le contrat implicite de ce que vous vous attendez à ce que les utilisateurs de votre interface d'avoir à connaître.

Si vous êtes de retour ou d'accepter des types de référence, alors vous êtes juste de dire qu'ils peuvent passer à travers un pointeur ou une référence sur lequel ils peuvent à leur tour sont connus qu'à travers une déclaration anticipée.

Lorsque vous êtes de retour incomplet, ce type de X f2(); alors que vous dites à votre interlocuteur doit ont la pleine spécification du type de X. Ils ont besoin pour créer de la LHS ou temporaire de l'objet sur le site d'appel.

De même, si vous acceptez un type incomplète, l'appelant doit avoir construit l'objet qui est le paramètre. Même si cet objet a été retourné comme un autre type incomplète à partir d'une fonction, le site d'appel a besoin de l'intégralité de la déclaration. c'est à dire:

class X;  //forward for two legal declarations 
X returnsX();
void XAcceptor(X);

XAcepptor( returnsX() );  //X declaration needs to be known here

Je pense qu'il y a un principe important qui un en-tête doit fournir suffisamment d'informations pour l'utiliser sans une dépendance nécessitant d'autres en-têtes. Cela signifie que l'en-tête doit être capable d'être inclus dans une unité de compilation sans provoquer une erreur de compilation lorsque vous utilisez toutes les fonctions qu'il déclare.

Sauf

1. Si cette dépendance externe est souhaité comportement. Au lieu d'utiliser la compilation conditionnelle, vous pouvez avoir un bien documenté obligation de fournir leur propre en-tête déclarant X. C'est une alternative à l'utilisation de #ifdefs et peut être un moyen utile d'introduire des objets fantaisie ou d'autres variantes.

2. La distinction importante en cours de certains modèle de techniques où vous sont explicitement PAS prévu de les instancier, mentionné juste pour quelqu'un ne reçoit pas désagréable avec moi.

Aussi longtemps que vous n'avez pas besoin de la définition (pensez à les pointeurs et les références), vous pouvez vous en sortir avec sa déclaration. C'est pourquoi le plus souvent, vous devriez voir dans les en-têtes tandis que les fichiers de mise en œuvre généralement va tirer l'en-tête de la définition appropriée(s).

Le prendre avant la déclaration d'obtenir votre code à la compilation (obj est créé). Liant toutefois (exe création) ne sera pas réussie à moins que les définitions sont trouvés.

Que, Luc Touraille a déjà expliqué qu'il est très bien où l'utiliser et ne pas utiliser avant la déclaration de la classe.

Je vais juste ajouter à ce pourquoi nous avons besoin de l'utiliser.

Nous devrions être en Avant de la déclaration dans la mesure du possible pour éviter les indésirables de l'injection de dépendances.

Comme #include fichiers d'en-tête sont ajoutés sur plusieurs fichiers par conséquent, si l'on ajoute un en-tête dans un autre fichier d'en-tête, il va ajouter indésirables de l'injection de dépendances dans les différentes parties de code source qui peut être évité en ajoutant #include l'en-tête dans .cpp fichiers dans la mesure du possible plutôt que de les ajouter à un autre fichier d'en-tête et de l'utilisation de la classe avant la déclaration dans la mesure du possible dans l'en-tête .h fichiers.