Fractionner les classes C++ en modèles.php/.dossiers du RPC--est-ce possible?

It is possible, tant que vous savez de quelles instanciations vous aurez besoin.

ajouter le code suivant à la fin de la pile.rpc et ça marchera :

template class stack<int>;

toutes les méthodes non-template de la pile seront instanciées, et l'étape de lien fonctionnera très bien.

Vous pouvez le faire de cette façon

// xyz.h
#ifndef _XYZ_
#define _XYZ_

template <typename XYZTYPE>
class XYZ {
  //Class members declaration
};

#include "xyz.cpp"
#endif

//xyz.cpp
#ifdef _XYZ_
//Class definition goes here

#endif

cela a été discuté dans Daniweb

aussi dans FAQ mais en utilisant le mot-clé export C++.

non, ce n'est pas possible. Pas sans le mot-clé export , qui, à toutes fins pratiques, n'existe pas vraiment.

le mieux que vous pouvez faire est de mettre vos implémentations de fonction dans un".cci" ou ".ppt fichier", et #inclure l' .cci de fichier à la fin de votre .php fichier. Cependant, ceci n'est que superficiel; c'est toujours la même chose que de tout mettre en œuvre dans les fichiers d'en-tête. C'est tout simplement le prix que vous payez pour utiliser les gabarits.

je crois qu'il y a deux raisons principales pour tenter de séparer le code templated en un en-tête et un cpp:

L'un est pour l'élégance. Nous aimons tous écrire du code qui est difficile à lire, à gérer et qui est réutilisable plus tard.

les Autres c'est la réduction du temps de compilation.

je suis actuellement (comme toujours) logiciel de simulation de codage en conjonction avec OpenCL et nous aimons garder le code afin qu'il puisse être exécuté en utilisant float (cl_float) ou double (cl_double) types selon les besoins en fonction de la capacité HW. Pour l'instant, cela se fait en utilisant un #define REAL au début du code, mais ce n'est pas très élégant. Pour changer la précision désirée, il faut recompiler l'application. Depuis il n'y a pas de réel moment de l'exécution, nous avons à vivre avec cela pour le moment. Heureusement, les noyaux OpenCL sont compilés pour l'exécution, et un simple sizeof (réel) nous permet de modifier l'exécution du code du noyau en conséquence.

le plus gros problème est que même si l'application est modulaire, lors du développement de classes auxiliaires (telles que celles qui pré-calculent les constantes de simulation) doivent également être modélisées. Ces classes apparaissent toutes au moins une fois au sommet de l'arbre des dépendances de classe, car la Simulation finale de classe de modèle aura une instance d'une de ces classes d'usine, ce qui signifie que pratiquement chaque fois que je fais un changement mineur à la classe d'usine, le logiciel entier doit être reconstruit. C'est très ennuyeux, mais je ne peux pas sembler trouver une meilleure solution.

parfois, il est possible d'avoir la plupart de l'implémentation cachée dans le fichier cpp, si vous pouvez extraire la fonctionnalité commune de tous les paramètres du modèle dans la classe non-modèle (peut-être type-unsafe). Alors header contiendra des appels de redirection vers cette classe. Une approche similaire est utilisée, lors de la lutte avec le problème "template bloat".

si vous savez avec quels types votre pile sera utilisée, Vous pouvez les instancier explicitement dans le fichier cpp, et y conserver tous les codes pertinents.

il est également possible de les exporter à travers des DLLs (!) mais il est assez difficile d'obtenir la bonne syntaxe (combinaisons MS-specific de __declspec(dllexport) et le mot clé d'exportation).

nous avons utilisé cela dans une lib math/geom que Templier double/float, mais avait tout à fait beaucoup de code. (J'ai googlé autour de il n'a pas ce code aujourd'hui.)

Le problème est qu'un modèle ne génère pas d'une classe réelle, c'est juste un modèle dire au compilateur comment générer une classe. Vous avez besoin de générer une classe concrète.

La manière facile et naturelle est de mettre les méthodes dans le fichier d'en-tête. Mais il existe une autre manière.

dans votre .cpp file, Si vous avez une référence à chaque instanciation et méthode de template que vous avez besoin, le compilateur les générera là pour utiliser tout au long de votre projet.

nouvelle pile.cpp:

#include <iostream>
#include "stack.hpp"
template <typename Type> stack<Type>::stack() {
        std::cerr << "Hello, stack " << this << "!" << std::endl;
}
template <typename Type> stack<Type>::~stack() {
        std::cerr << "Goodbye, stack " << this << "." << std::endl;
}
static void DummyFunc() {
    static stack<int> stack_int;  // generates the constructor and destructor code
    // ... any other method invocations need to go here to produce the method code
}

vous devez avoir tout dans le fichier hpp. Le problème est que les classes ne sont pas réellement créées jusqu'à ce que le compilateur voit qu'elles sont nécessaires pour un autre fichier cpp - il doit donc avoir tout le code disponible pour compiler la classe templated à ce moment-là.

une chose que j'ai tendance à faire est d'essayer de diviser mes modèles en une partie générique non-templated (qui peut être divisée entre cpp/hpp) et la partie type-specific template qui hérite du non-templated classe.

uniquement si vous #include "stack.cpp à la fin de stack.hpp . Je ne recommande cette approche que si la mise en œuvre est relativement importante, et si vous renommez le .rpc fichier à un autre poste, comme pour le différencier de code standard.

C'est une question assez ancienne, mais je pense qu'il est intéressant de regarder la présentation de Arthur O'Dwyer à la cppcon 2016 . Bonne explication, beaucoup de sujet couvert, à surveiller absolument.

parce que les gabarits sont compilés au besoin, cela impose une restriction pour les projets multi-fichiers: la mise en œuvre (définition) d'une classe de gabarits ou d'une fonction doit être dans le même fichier que sa déclaration. Cela signifie que nous ne pouvons pas séparer l'interface dans un fichier d'en-tête séparé, et que nous devons inclure à la fois l'interface et la mise en œuvre dans tout fichier qui utilise les modèles.

une autre possibilité est de faire quelque chose comme:

#ifndef _STACK_HPP
#define _STACK_HPP

template <typename Type>
class stack {
    public:
            stack();
            ~stack();
};

#include "stack.cpp"  // Note the include.  The inclusion
                      // of stack.h in stack.cpp must be 
                      // removed to avoid a circular include.

#endif

Je n'aime pas cette suggestion comme une question de style, mais il peut vous convenir.

le mot clé "exporter" permet de séparer la mise en œuvre du modèle de la déclaration du modèle. Ceci a été introduit dans la norme C++ sans une implémentation existante. En temps voulu seulement quelques compilateurs l'ont réellement mis en œuvre. Lire en profondeur l'information à Inform IT article sur l'exportation

1) rappelez-vous la raison principale de se séparer .h et .les fichiers cpp est de cacher l'implémentation de classe comme un code Obj compilé séparément qui peut être lié au code de l'utilisateur qui a inclus A.h de la classe.

2) Les classes sans modèle ont toutes les variables concrètement et spécifiquement définies dans .h et .fichiers cpp. Ainsi, le compilateur aura besoin d'informations sur tous les types de données utilisés dans la classe avant de compiler/traduire: code Les classes de modèles n'ont aucune information sur le type de données spécifique avant que l'utilisateur de la classe instancie un objet passant le type de données requis:

        TClass<int> myObj;

3) ce N'est qu'après cette instanciation que le compilateur génère la version spécifique de la classe template pour correspondre au(x) type (S) de données passé (s).

4) par conséquent,.le cpp ne peut pas être compilé séparément sans connaître le type de données de l'utilisateur. Il doit donc rester comme code source".h" jusqu'à l'utilisateur de spécifier le type de données requis, il peut être généré à un type de données spécifique, puis compilé

je travaille avec Visual studio 2010, si vous souhaitez diviser vos fichiers .h et .rpc, inclure votre rpc-tête à la fin de l' .h fichier