Séparer le code de classe dans un en-tête et un fichier cpp

Je suis confus sur la façon de séparer la mise en œuvre et les déclarations de code d'une classe simple dans un nouvel en-tête et un fichier cpp. Par exemple, comment pourrais-je séparer le code pour la classe suivante?

class A2DD
{
  private:
  int gx;
  int gy;

  public:
  A2DD(int x,int y)
  {
    gx = x;
    gy = y;
  }

  int getSum()
  {
    return gx + gy;
  }
};

Juste un couple de commentaires: Le constructeur doit toujours utiliser une liste d'initialisation au lieu de mettre les membres dans le corps. Pour une bonne et simple explication, voir: codeguru.com/forum/showthread.php?t=464084 C'est aussi, au moins la plupart des endroits, de coutume d'avoir le champ public au top. Il n'affecte en quoi que ce soit, mais, étant donné que le champs est la documentation de votre classe, il est logique d'avoir que dans le haut.
Ayant public: membres au sommet pourraient affecter beaucoup de choses, si l'utilisateur déplace selon cet avis -, mais avait de la commande de dépendances entre les membres et n'était pas encore au courant que les membres sont initialisées dans l'ordre de leur déclaration 😉
ce qui est vrai. Mais là encore, nous sommes tous de la compilation avec les avertissements d'erreurs et de tous les avertissement que nous pouvons penser, à droite? Au moins vous dire que vous êtes vissage cette place, mais ouais, les gens utilisent de manière à peu mises en garde, et il suffit de les ignorer 🙁
Bon point, un peu oublié qui génère des avertissements - si seulement les avertissements ont été lus par la plupart 🙂 je les utiliser et d'essayer de code tous. Quelques-uns sont inévitables, alors je dis 'merci pour l'avertissement, mais je sais ce que je veux faire!" - mais la plupart sont mieux fixés pour éviter toute confusion plus tard.

InformationsquelleAutor drdrdr | 2012-03-06

c++class oop

200

La déclaration de classe va dans le fichier d'en-tête. Il est important que vous ajoutez le #ifndef inclure des gardes, ou si vous êtes sur une MME plateforme vous pouvez également utiliser #pragma once. Aussi, j'ai omis le privé, par défaut, les membres de classe C++ sont privés.
```
//A2DD.h
#ifndef A2DD_H
#define A2DD_H

class A2DD
{
  int gx;
  int gy;

public:
  A2DD(int x,int y);
  int getSum();

};

#endif
```
et la mise en œuvre de passe dans le fichier CPP:
```
//A2DD.cpp
#include "A2DD.h"

A2DD::A2DD(int x,int y)
{
  gx = x;
  gy = y;
}

int A2DD::getSum()
{
  return gx + gy;
}
```
- N'oubliez pas que si vous faites modèle de programmation, alors vous devez garder tout dans la .h fichier, de sorte que le compilateur va instancier le bon code au moment de la compilation.
- im obtenir une erreur, un double symbole im pas sûr de la façon de slove il .ld: dupliquer le symbole A2DD::A2DD(int, int)dans ./src/rstring.o et ./src/A2DD.o pour l'architecture x86_64
- avez-vous le #ifndef des trucs dans la tête?
- doh. j'ai été de l'importation de la "A2DD.cpp" au lieu de "A2DD.h" qui fixe le double symbole de problème.
- Cela signifie donc que tous les fichiers qui incluent votre fichier d'en-tête va "voir" les membres privés. Si par exemple vous souhaitez publier une lib et son en-tête, vous devez montrer les membres privés de la classe?
- Non, il y a la belle de mise en œuvre de l'idiome: en.wikipedia.org/wiki/Opaque_pointer Vous pouvez l'utiliser pour cacher les détails d'implémentation.
- Techniquement: oui. Toutefois, en déplaçant les soldats à une autre classe, vous n'avez pas nécessairement à partager que classe publiquement. fritzone du lien montre comment faire.
- linello: Si je l'aurais vu votre commentaire avant de.... J'ai perdu quelques heures de la question, jusqu'à ce que j'ai essayé de copier le rpc code ci-dessous le fichier d'en-tête et tout a bien fonctionné... en fait, vous pouvez séparer ces fichiers si vous incluez la rpc à la fin de l' .h fichier juste avant le #endif
- uniquement si le modèle est instancié dans d'autres unités de traduction. E. g. un modèle de méthode privée ne peut être défini dans le .cpp sans problème
- Comment utiliser this mot dans le .rpc fichier à l'aide de cette séparation?
InformationsquelleAutor Ferenc Deak

En général votre .h contient la classe defition, qui est l'ensemble de vos données et tous vos déclarations de méthode. Comme dans votre cas:

A2DD.h:

class A2DD
{
  private:
  int gx;
  int gy;

  public:
  A2DD(int x,int y);    
  int getSum();
};

Et alors votre .rpc contient les implémentations des méthodes comme ceci:

A2DD.cpp:

A2DD::A2DD(int x,int y)
{
  gx = x;
  gy = y;
}

int A2DD::getSum()
{
  return gx + gy;
}

InformationsquelleAutor Nick

Essentiellement d'une version modifiée de la syntaxe de déclaration de fonction/définitions:

a2dd.h

class A2DD
{
private:
  int gx;
  int gy;

public:
  A2DD(int x,int y);

  int getSum();
};

a2dd.cpp

A2DD::A2DD(int x,int y)
{
  gx = x;
  gy = y;
}

int A2DD::getSum()
{
  return gx + gy;
}

InformationsquelleAutor Corbin

4

A2DD.h
```
class A2DD
{
private:
  int gx;
  int gy;

public:
  A2DD(int x,int y);

  int getSum();
};
```
A2DD.cpp
```
  A2DD::A2DD(int x,int y)
  {
    gx = x;
    gy = y;
  }

  int A2DD::getSum()
  {
    return gx + gy;
  }
```
L'idée est de garder toutes les signatures de la fonction et des membres dans le fichier d'en-tête.

Cela va permettre à d'autres fichiers de projet pour voir comment la classe ressemble sans avoir à connaître la mise en œuvre.

Et en plus de cela, vous pouvez alors inclure d'autres fichiers d'en-tête dans la mise en place de l'en-tête. Ceci est important car, selon les en-têtes sont inclus dans votre fichier d'en-tête sera inclus (hérité) dans un autre fichier qui contient votre fichier d'en-tête.

InformationsquelleAutor Yochai Timmer
4

Il est important de préciser aux lecteurs tombent sur cette question lors de la recherche de l'objet dans un cadre plus large de la mode que l'on a accepté la réponse de la procédure n'est pas requise dans le cas où vous ne voulez diviser votre projet dans les fichiers. Il est uniquement nécessaire lorsque vous avez besoin de plusieurs implémentations des classes uniques. Si votre mise en œuvre par classe est un, juste un fichier d'en-tête pour chaque suffit.

Par conséquent, de la accepté de répondre à l'exemple de la seule cette partie est nécessaire:
```
#ifndef MYHEADER_H
#define MYHEADER_H

//Class goes here, full declaration AND implementation

#endif
```
Le #ifndef etc. définitions de préprocesseur lui permettre d'être utilisé plusieurs fois.

PS. Le sujet devient plus clair une fois que vous vous rendez compte C/C++ est "idiot", et #include est simplement une façon de dire "vidage de ce texte à cet endroit".
- pourriez-vous faire cela en mettant le "split" les fichiers dans .cpp, ou n'est .h vraiment de "bon" pour cette méthode d'organisation de code?
InformationsquelleAutor j riv
3

Vous laissez les déclarations dans le fichier d'en-tête:
```
class A2DD
{
  private:
  int gx;
  int gy;

  public:
    A2DD(int x,int y); //leave the declarations here
    int getSum();
};
```
Et de mettre les définitions dans le fichier d'implémentation.
```
A2DD::A2DD(int x,int y) //prefix the definitions with the class name
{
  gx = x;
  gy = y;
}

int A2DD::getSum()
{
  return gx + gy;
}
```
Vous pouvez mélanger les deux (congé getSum() définition dans l'en-tête par exemple). C'est utile car il donne le compilateur une meilleure chance à l'in-lining, par exemple. Mais cela signifie aussi que la modification de la mise en œuvre (si on les laisse dans l'en-tête) pourrait déclencher une reconstruction de tous les autres fichiers qui incluent l'en-tête.

Noter que pour les modèles, vous devez conserver tous les dans les en-têtes.
- Mettre privée des membres et des fonctions dans le fichier d'en-tête n'est pas considéré comme une fuite détails de mise en œuvre?
- en quelque sorte. Ceux-ci sont nécessaire détails de mise en œuvre. E. g., J'ai besoin de savoir combien d'espace une classe va consommer sur la pile. Les implémentations de fonctions ne sont pas nécessaires pour les autres unités de compilation.
InformationsquelleAutor Mat

Généralement vous mettre uniquement des déclarations et très peu de fonctions en ligne dans le fichier d'en-tête:

Par exemple:

class A {
 public:
  A(); //only declaration in the .h unless only a short initialization list is used.

  inline int GetA() const {
    return a_;
  }

  void DoSomethingCoplex(); //only declaration
  private:
   int a_;
 };

InformationsquelleAutor Ivaylo Strandjev

Vous devez vous connecter pour publier un commentaire.