Lorsque j'écris des modèles de classe et que j'ai besoin de spécialiser complètement les membres de ces classes, Doxygen ne reconnaît pas la spécialisation - il documente seulement la définition générique ou (s'il n'y a que des spécialisations) la dernière définition. Voici un exemple simple:Doxygen pour la spécialisation des membres de la classe modèle C++
=== === MyClass.hpp
#ifndef MYCLASS_HPP
#define MYCLASS_HPP
template<class T> class MyClass{
public:
static void foo();
static const int INT_CONST;
static const T TTYPE_CONST;
};
/* generic definitions */
template<class T>
void MyClass<T>::foo(){
printf("Generic foo\n");
}
template<class T>
const int MyClass<T>::INT_CONST = 5;
/* specialization declarations */
template<> void MyClass<double>::foo();
template<> const int MyClass<double>::INT_CONST;
template<> const double MyClass<double>::TTYPE_CONST;
template<> const char MyClass<char>::TTYPE_CONST;
#endif
=== === MyClass.cpp
#include "MyClass.hpp"
/* specialization definitions */
template<>
void MyClass<double>::foo(){
printf("Specialized double foo\n");
}
template<> const int MyClass<double>::INT_CONST = 10;
template<> const double MyClass<double>::TTYPE_CONST = 3.141;
template<> const char MyClass<char>::TTYPE_CONST = 'a';
Donc dans ce cas, foo() sera être documenté comme impression "foo générique", INT_CONST sera documenté comme défini à 5, sans mention des spécialisations, et TTYPE_CONST sera documenté comme étant réglé sur "a", sans mention de 3.141 et aucune indication que "a" est un cas spécialisé.
Je dois être en mesure de documenter les spécialisations - soit dans la documentation pour MyClass<T>, ou sur de nouvelles pages pour MyClass<double>, MyClass<char>. Comment puis-je faire cela? Est-ce que Doxygen peut même gérer ça? Est-ce que je fais quelque chose de mal dans la structure des déclarations/codes qui empêche Doxygen de comprendre ce que je veux?
je devrais noter deux affaires:
A) Pour les fonctions templated, spécialisation fonctionne très bien, par exemple .:
/* functions that are global/in a namespace */
template<class T> void foo(){ printf("Generic foo\n"); }
template<> void foo<double>(){ printf("Specialized double foo\n"); }
Ce documentera les deux foo<T>() et foo<double>(). B) Si je redéclare le modèle entier, c'est-à-dire template<> class MyClass<double>{...};, alors MyClass<double> obtiendra sa propre page de documentation, en tant que classe séparée. Mais cela signifie en réalité déclarer une classe entièrement nouvelle - il n'y a pas de relation entre MyClass<T> et MyClass<double> si MyClass<double> est elle-même déclarée. Donc, je devrais redéclarer la classe et tous ses membres, et répéter toutes les définitions des membres de la classe, spécialisée pour MyClass<double>, tout pour faire apparaître comme si ils utilisent le même modèle. Très gênant, se sent comme une solution kludge.
Suggestions? Merci beaucoup :)
--Ziv