जब मैं कक्षा टेम्पलेट्स लिखता हूं, और उन वर्गों के सदस्यों को पूरी तरह से विशेषज्ञ करने की आवश्यकता होती है, तो डॉक्सिजन विशेषज्ञता को पहचान नहीं पाती है - यह केवल सामान्य परिभाषा दस्तावेज करती है, या (यदि केवल विशेषज्ञताएं हैं) अंतिम परिभाषा। यहाँ एक सरल उदाहरण है:सी ++ टेम्पलेट क्लास सदस्य विशेषज्ञता के लिए डॉक्सिजन
=== 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';
तो, foo() होगा "जेनेरिक फू" प्रिंटिंग के रूप में दस्तावेज किया जाना चाहिए, INT_CONST को 5 के सेट के रूप में दस्तावेज किया जाएगा, जिसमें विशेषज्ञता का कोई उल्लेख नहीं है, और TTYPE_CONST को 'ए' पर सेट के रूप में दस्तावेज किया जाएगा, जिसमें 3.141 का कोई उल्लेख नहीं है और कोई संकेत नहीं है कि 'ए' एक विशेष मामला
मुझे विशेषज्ञता को दस्तावेज करने में सक्षम होना चाहिए - या तो MyClass<T> के लिए प्रलेखन के भीतर, या MyClass<double>, MyClass<char> के लिए नए पृष्ठों पर। मैं यह कैसे करु? क्या डॉक्सिजन भी इसे संभाल सकता है? क्या मैं संभवतः घोषणाओं/कोड संरचना में कुछ गलत कर रहा हूं जो डॉक्सिजन को जो भी मैं चाहता हूं उसे समझने से रोक रहा हूं?
मैं दो से जुड़े मामलों पर ध्यान देना चाहिए:
ए) टेम्प्लेट कार्यों के लिए, विशेषज्ञता ठीक, उदा .:
/* 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"); }
काम करता है यह foo<T>() और foo<double>() दोनों दस्तावेज़ होगा।
बी) यदि मैं पूरे टेम्पलेट को पुन: प्राप्त करता हूं, यानी template<> class MyClass<double>{...};, तो MyClass<double> को एक अलग वर्ग के रूप में अपना स्वयं का दस्तावेज़ पृष्ठ प्राप्त होगा। लेकिन इसका मतलब है कि वास्तव में एक पूरी तरह से नई कक्षा घोषित करना - MyClass<T> और MyClass<double> के बीच कोई संबंध नहीं है यदि MyClass<double> स्वयं घोषित किया गया है। इसलिए मुझे कक्षा और उसके सभी सदस्यों को फिर से शुरू करना होगा, और कक्षा सदस्यों की सभी परिभाषाओं को दोहराएं, MyClass<double> के लिए विशेष, यह सब ऐसा प्रतीत होता है कि वे एक ही टेम्पलेट का उपयोग कर रहे हैं। बहुत अजीब, एक क्लज समाधान की तरह लगता है।
सुझाव? धन्यवाद बहुत :)
--Ziv