temps de réflexion-Pourquoi voulez-vous diviser votre dossier de toute façon?

comme le titre le suggère, le problème final que j'ai Est des erreurs de linker de définitions multiples. J'ai en fait réglé le problème, mais je n'ai pas réglé le problème de la bonne façon. Avant de commencer, je veux discuter des raisons pour diviser un fichier de classe en plusieurs fichiers. J'ai essayé de mettre tous les scénarios possibles ici - si j'en ai manqué un, s'il vous plaît Rappelez-moi et je peux faire des changements. J'espère que la sont corrects:

raison 1 pour économiser de l'espace:

Vous avez un fichier contenant la déclaration d'une classe avec tous les membres de la classe. Vous placez #include guards autour de ce fichier (ou #pragma une fois) pour vous assurer qu'aucun conflit ne survienne si vous #incluez le fichier dans deux fichiers d'en-tête différents qui sont ensuite inclus dans un fichier source. Vous compilez un fichier source séparé avec le implémentation de toutes les méthodes déclarées dans cette classe, car elle ne charge pas beaucoup de lignes de code à partir de votre fichier source, ce qui nettoie un peu les choses et introduit un peu d'ordre dans votre programme.

exemple: comme vous pouvez le voir, l'exemple ci-dessous pourrait être amélioré en divisant l'implémentation des méthodes de classe en un fichier différent. (Un. fichier cpp)

// my_class.hpp
#pragma once

class my_class
{
public:
    void my_function()
    {
        // LOTS OF CODE
        // CONFUSING TO DEBUG
        // LOTS OF CODE
        // DISORGANIZED AND DISTRACTING
        // LOTS OF CODE
        // LOOKS HORRIBLE
        // LOTS OF CODE
        // VERY MESSY
        // LOTS OF CODE
    }

    // MANY OTHER METHODS
    // MEANS VERY LARGE FILE WITH LOTS OF LINES OF CODE
}

Raison 2 pour prévenir les erreurs de linker de définition multiple:

peut-être est-ce la principale raison pour laquelle vous avez divisé la mise en œuvre de la déclaration. Dans l'exemple ci-dessus, vous pouvez déplacer le corps de la méthode à l'extérieur de la classe. Cela le rendrait beaucoup plus propre et structuré. Cependant, selon cette question , l'exemple ci-dessus a des spécificateurs implicites inline . Le transfert de la mise en œuvre de l'intérieur de la class à l'extérieur de la classe, comme dans l'exemple ci-dessous, va vous causer des erreurs de linker, et donc vous seriez soit tout en ligne, ou déplacer les définitions de fonction à A.fichier cpp.

exemple: _l'exemple ci-dessous provoquera des "erreurs de linker à Définition multiple" si vous ne déplacez pas la définition de la fonction vers A.fichier cpp ou spécifiez la fonction inline.

// my_class.hpp
void my_class::my_function()
{
    // ERROR! MULTIPLE DEFINITION OF my_class::my_function
    // This error only occurs if you #include the file containing this code
    // in two or more separate source (compiled, .cpp) files.
}

pour corriger le problème:

//my_class.cpp
void my_class::my_function()
{
    // Now in a .cpp file, so no multiple definition error
}

ou:

// my_class.hpp
inline void my_class::my_function()
{
    // Specified function as inline, so okay - note: back in header file!
    // The very first example has an implicit `inline` specifier
}

Raison 3 vous voulez économiser de l'espace, encore une fois, mais cette fois vous travaillez avec une classe de modèle:

si nous travaillons avec des classes de template, alors nous ne pouvons pas déplacer l'implémentation vers un fichier source (.fichier cpp). Ce n'est actuellement pas autorisé par (je suppose) la norme ou par compilateurs actuels. Contrairement au premier exemple de Raison 2 , ci-dessus, nous sommes autorisés à placer l'implémentation dans le fichier d'en-tête. Selon cette question la raison est que les méthodes de classe de gabarit ont également impliqué inline spécificateurs. Est-ce exact? (Il semble de bon sens.) Mais personne ne semblait savoir sur la question que je viens référencés!

donc, les deux exemples ci-dessous sont-ils identiques?

// some_header_file.hpp
#pragma once

// template class declaration goes here
class some_class
{
    // Some code
};

// Example 1: NO INLINE SPECIFIER
template<typename T>
void some_class::class_method()
{
    // Some code
}

// Example 2: INLINE specifier used
template<typename T>
inline void some_class::class_method()
{
    // Some code
}

si vous avez une classe de modèle fichier d'en-tête, qui devient énorme en raison de toutes les fonctions que vous avez, alors je crois que vous êtes autorisé à déplacer les définitions de fonction à un autre fichier d'en-tête (généralement un .ppt fichier?) et ensuite #include file.tpp à la fin de votre fichier d'en-tête contenant la déclaration de classe. Vous ne devez pas inclure ce fichier ailleurs, cependant, d'où le .tpp plutôt que .hpp .

je suppose que vous pourriez aussi faire cela avec les méthodes en ligne d'une classe régulière? Est qui a permis aussi?

Heure Des Questions

donc j'ai fait quelques déclarations ci-dessus, dont la plupart se rapportent à la structuration des fichiers source. Je pense que tout ce que j'ai dit était correct, parce que j'ai fait quelques recherches de base et "découvert quelques trucs", mais c'est une question et donc je ne sais pas pour sûr.

ce que cela revient à, c'est comment vous organiseriez le code dans les fichiers. Je pense avoir trouvé une structure qui fonctionnera toujours.

voici ce que j'ai trouvé. (C'est "Ed Oiseau de classe du fichier de code de l'organisation / structure standard" , si vous le souhaitez. Je ne sais pas si ce sera encore très utile, c'est le but de demander.)

• 1: déclarez la classe (modèle ou autre) dans un fichier .hpp , y compris toutes les méthodes, les fonctions d'ami et les données.
• 2: Au bas du fichier .hpp , #include un fichier .tpp contenant la mise en œuvre de toute méthode inline . Créez le fichier .tpp et assurez-vous que toutes les méthodes sont spécifiées comme étant inline .
• 3: tous les autres membres (fonctions non-inline, fonctions d'ami et données statiques) doivent être définis dans un fichier .cpp , qui #include s le fichier .hpp en haut pour prévenir les erreurs comme " classe ABC a pas été déclarée". Puisque tout dans ce fichier aura un lien externe, le programme se liera correctement.

Existe-t-il des normes de ce type dans l'industrie? La norme je suis venu avec le travail dans tous les cas?