टेम्पलेट मेटाप्रोग्रामिंग

नमूना मेटाप्रोग्रामिंग टीएमपी एक मापन और संख्यात्मक तकनीक है जिसमें एक संकलक द्वारा अस्थायी स्रोत पारण चिन्ह उत्पन्न करने के लिए सामान्य कार्यक्रम का उपयोग करता है जिसमें कंपाइलर द्वारा शेष स्रोत सांकेतिक चिन्ह के साथ विलय कर दिया जाता है और फिर संकलित किया जाता है इन नमूनों के आउटपुट में संकलन समय लगातार कार्यक्रम की डेटा संरचना और पूरे समारोह कंप्यूटर विज्ञान में सम्मिलित हो सकते हैं जो नमूने के उपयोग को संकलन-समय कार्यक्रम निष्पादन को बहुरूपता के रूप में माना जा सकता है इस तकनीक का उपयोग कई भाषाओं में किया जाता है जिनमें से सबसे प्रसिद्ध सी ++ है लेकिन गोल कार्यक्रम भाषा डी कार्यक्रम भाषा शंकु कार्यक्रम भाषा और एक्सएल कार्यक्रम भाषा भी है

नमूना मेटाप्रोग्रामिंग का अर्थ गलती से खोजा गया था ^[1]^[2]कुछ अन्य भाषाएं इसी तरह का समर्थन करती हैं यदि अधिक शक्तिशाली संकलन-समय की सुविधाएं जैसे एलआईएसपी कार्यक्रमिक भाषा मैक्रो कंप्यूटर विज्ञान वाक्य लेख के बाहर हैं।

टेम्पलेट मेटाप्रोग्रामिंग के घटक

मेटाप्रोग्रामिंग तकनीक के रूप में नमूने के उपयोग के लिए दो अलग-अलग संचालन की आवश्यकता होती है जिसमें एक नमूने को परिभाषित किया गया है इसके उदाहरण कंप्यूटर विज्ञान में होना चाहिए योजना में लाए गए स्रोत में सांकेतिक चिन्ह नमूने के रूप में वर्णित हैं और जब नमूने में सामान्य रूप का उपयोग सांकेतिक चिन्ह के विशिष्ट समूह को उत्पन्न करने के लिए किया जाता है

तो नमूना मेटाप्रोग्रामिंग अभिकलनीय पूर्ण है जिसका अर्थ है कि कंप्यूटर कार्यक्रम द्वारा अभिव्यक्त किसी भी संगणना की गणना किसी न किसी रूप में की जा सकती है और ^[3]नमूने मैक्रो कंप्यूटर विज्ञान कार्यक्रम मैक्रोज़ से अलग हैं एक मैक्रो सांकेतिक चिन्ह का टुकड़ा जो संकलन समय पर निष्पादित होता है ये संकलित किए जाने वाले सांकेतिक चिन्ह का शाब्दिक हेरफेर करता है जैसे C ++ संकलक द्वारा उत्पादित सार वाक्य रचना के पेड़ में हेरफेर करता है जैसे जंग कार्यक्रम भाषा या एलआईएसपी कार्यक्रमिक भाषा है इसमें शाब्दिक शब्दों की हेरफेर की जा रही भाषा के वाक्य से अधिक स्वतंत्र हैं क्योंकि वे संकलन से ठीक पहले स्रोत चिन्ह के इन याददास्त को बदलते हैं।

नमूना मेटाप्रोग्राम में कोई अपरिवर्तनीय वस्तु नहीं है अर्थात एक बार प्रारंभ होने के बाद कोई चर मूल्य नहीं बदल सकता है इसलिए नमूना मेटाप्रोग्रामिंग को कार्यात्मक के रूप में देखा जा सकता है वास्तव में कई नमूना कार्यान्वयन प्रवाह नियंत्रण को केवल पुनरावर्तन कंप्यूटर विज्ञान के माध्यम से लागू करते हैं।

नमूना मेटाप्रोग्रामिंग का उपयोग

नमूना मेटाप्रोग्रामिंग का वाक्य भाषा से बहुत अलग होता है जिसके साथ इसका उपयोग किया जाता है जो इसके व्यावहारिक उपयोग हैं नमूने जिसमें उपयोग करने के कुछ सामान्य कारण लागू किये जाते हैं चिन्ह के भागों के कुछ स्थानों के बदलावों को छोड़कर समान हैं तथा स्वत: संकलन-समय अनुकूलन करने के लिए जैसे कि हर कार्यक्रम चलाने के बाद संकलन कुछ करना चाहता है उदाहरण के लिए जब भी कार्यक्रम निष्पादित किया जाता है तो गणना और बंधन गणना वृद्धि को खत्म करने के लिए मेटाप्रोग्रामिंग का उपयोग किया जाता है।

संकलन पीढ़ी

संकलन समय में कार्यक्रम का क्या अर्थ है इसे गुणनखण्ड कार्यक्रम के उदाहरण के साथ चित्रित किया जा सकता है जो गैर नमूने सी ++ में प्रतिवर्तन का उपयोग करके निम्नानुसार लिखा जा सकता है।

अहस्तांक्षरित गुणनखण्ड तथा अहस्ताक्षरित n वापसी n = 0 , 1 एन गुणनखण्ड एन - 1 है

उपयोग के उदाहरण // गुणनखण्ड 0 से 1 निकलेगा // गुणनखण्ड 4 से 24 निकलेगा।

शाब्दिक 0 और 4 के भाज्य मान को निर्धारित करने के लिए उपरोक्त चिन्ह समय पर निष्पादित होगा पुनरावर्तन के लिए अंतिम स्थिति प्रदान करने के लिए नमूना मेटाप्रोग्रामिंग और नमूना विशेषज्ञता का उपयोग करके कार्यक्रम में उपयोग किए जाने वाले गुणनखण्ड उपयोग नहीं किए गए किसी भी गुणनखण्ड को अनदेखा करते हुए इस चिन्ह द्वारा संकलन समय की गणना की जा सकती है

नमूना < अहस्तांक्षरित एन > संरचना भाज्य स्थैतिक अहस्तांक्षरित मूल्य = एन भाज्य < एन - 1 : : मूल्य

नमूना < > चित्र गुणनखण्ड <0> में स्थैतिक अहस्तांक्षरित मूल्य = 1 है

संकलन-समय कोड अनुकूलन

उपरोक्त गुणनखण्ड संकलन-समय सांकेतिक चिन्ह अनुकूलन का एक उदाहरण है जिसमें कार्यक्रम द्वारा उपयोग किए जाने वाले सभी गुणनखण्ड पूर्व-संकलित होते हैं और संकलन पर संख्यात्मक स्थिरांक के रूप में अंत: प्रवेश किए जाते हैं समय दौड़ के अतिरिक्त पद चिन्ह दोनों को बचाते हैं जबकि यह अपेक्षाकृत निम्न अनुकूलन है।

दूसरे के रूप में अधिक महत्वपूर्ण संकलन समय बंधन अनियंत्रत का उदाहरण है नमूना मेटाप्रोग्रामिंग का उपयोग लंबाई एन सदिश वर्ग बनाने के लिए किया जा सकता है जहां एन को संकलन समय पर जाना जाता है अधिक पारंपरिक लंबाई-एन सदिश के लाभ यह है कि बंधन को अनियंत्रित किया जा सकता है जिसके परिणामस्वरूप बहुत अनुकूलित सांकेतिक चिन्ह होता है एक उदाहरण के रूप में अतिरिक्त चालक पर विचार करें तथा लंबाई-एन सदिश जोड़ को इस रूप में लिखा जा सकता है।

नमूना < int  लंबाई > 
सदिश < लंबाई > और :: चालक + = (स्थिरांक सदिश < लंबाई >& आरएसएच )  
{ 
    for  ( int  i  =  0 ;  i  <  लंबाई ++ i ) 
        मान [ i ]  +=  आरएचएस । मूल्य [ मैं ] }

जब संक्षिप्त विवरण , विवरण को चालू करता है तो यह एक चिन्ह विवरण करता है । ^{[ उद्धरण वांछित ]}

template <>
Vector<2>& Vector<2>::operator+=(const Vector<2>& rhs) 
{
    value[0] += rhs.value[0];
    value[1] += rhs.value[1];
    return *this;
}

स्थैतिक बहुरूपता

स्थैतिक बहुरूपता एक सामान्य मानक कार्यक्रम सुविधा है जहां व्युत्पन्न वस्तुओं को उनके मूल वस्तु के उदाहरणों के रूप में उपयोग किया जा है तथा व्युत्पन्न वस्तुओं के तरीकों को लागू भी किया जाता है जैसा कि इस चिन्ह में है-

class Base
{
public:
    virtual void method() { std::cout << "Base"; }
    virtual ~Base() {}
};

class Derived : public Base
{
public:
    virtual void method() { std::cout << "Derived"; }
};

int main()
{
    Base *pBase = new Derived;
    pBase->method(); //outputs "Derived"
    delete pBase;
    return 0;
}

जहां आह्वान आभाषी विधियाँ सर्वाधिक व्युत्पन्न वर्ग की होंगी यह गतिशील रूप से बहुरूपी व्यवहार पर सदिश के निर्माण द्वारा प्राप्त किया जाता है आभाषी विधियों के साथ कक्षाओं के लिए आभाषी देख-रेख जो समय दौड़ पर चलाये जाते हैं ताकि आह्वान की जाने वाली विधि की पहचान हो सके इस प्रकार समय बहुरूपता आवश्यक रूप से निष्पादन हो सके जबकि आधुनिक वास्तुकला पर अतिरिक्त जोर देता है।

कई जगह में आवश्यक बहुरूपी व्यवहार अपरिवर्तनीय है और संकलन समय पर निर्धारित कियासकता है फिर जिज्ञासु आवर्ती नमूना सांकेतिक चिन्ह सी आर टी पी का उपयोग स्थैतिक बहुरूपता को प्राप्त करने के लिए किया जा सकता है जो कार्यक्रम चिन्ह में बहुरूपता की नकल है लेकिन जिसे संकलन समय पर हल किया जाता है और इस प्रकार दौड़ समय आभाषी से दूर हो जाता है उदाहरण के लिए

template <class Derived>
struct base
{
    void interface()
    {
         // ...
         static_cast<Derived*>(this)->implementation();
         // ...
    }
};

struct derived : base<derived>
{
     void implementation()
     {
         // ...
     }
};

यहां बहुविधि नमूना इस तथ्य का लाभ उठाता है कि सदस्य कार्यक्रम निकायों को उनकी घोषणा के बाद तक तत्काल नहीं करता है और यह व्युत्पन्न वर्ग के सदस्यों को अपने स्वयं के सदस्य कार्यों के उपयोग के माध्यम से उपयोग करता है इस प्रकार संकलन में बहुरूपी विशेषताओं के साथ एक वस्तु रचना उत्पन्न होती है जो वास्तविक दुनिया के उपयोग के उदाहरण के रूप में सीआरटीपी का उपयोग मानक पुस्तकालय में किया जाता है जिसे कभी-कभी प्रतिबंधित नमूना विस्तार के रूप में संदर्भित किया जाता है जहां इसे सामान्य कार्यक्षमता को एक आधार वर्ग में रखा जा सकता है जिसका उपयोग अनुबंध के रूप में नहीं बल्कि सांकेतिक चिन्ह को कम करते हुए व्यवहार के अनुरूप को लागू करने के लिए एक आवश्यक घटक के रूप में किया जाता है।

स्थिर पीढ़ी

स्थैतिक तालिकाओं का लाभ एक साधारण सारणी अनुक्रमण कार्यविधि के साथ महंगी गणनाओं का प्रतिस्थापन है उदाहरण के लिए सी ++ में संकलन समय पर स्थिर तालिका उत्पन्न करने के एक से अधिक तरीके एकत्र हैं निम्न सूची पुनरावर्ती चित्र और विविध नमूने का उपयोग करके एक बहुत ही सरल तालिका बनाने का एक उदाहरण दिखाती है तालिका का आकार दस है प्रत्येक मान सूचकांक का वर्ग है।

#include <iostream>
#include <array>

constexpr int TABLE_SIZE = 10;

/**
 * Variadic template for a recursive helper struct.
 */
template<int INDEX = 0, int ...D>
struct Helper : Helper<INDEX + 1, D..., INDEX * INDEX> { };

/**
 * Specialization of the template to end the recursion when the table size reaches TABLE_SIZE.
 */
template<int ...D>
struct Helper<TABLE_SIZE, D...> {
  static constexpr std::array<int, TABLE_SIZE> table = { D... };
};

constexpr std::array<int, TABLE_SIZE> table = Helper<>::table;

enum  {
  FOUR = table[2] // compile time use
};

int main() {
  for (int i=0; i < TABLE_SIZE; i++) {
    std::cout << table[i]  << std::endl; // run time use
  }
  std::cout << "FOUR: " << FOUR << std::endl;
}

इसके पीछे विचार यह है कि चित्र सहायता पुनरावर्ती रूप से एक संरचना का उदाहरण है इस विषय सूची के रूप में गणना की गई है कि जब तक नमूने की विशेषज्ञता 10 तत्वों के आकार पर पुनरावृत्ति समाप्त नहीं करती विशेषज्ञता केवल चर तर्क सूची का उपयोग सारणी के तत्वों के रूप में करती है संकलक समान सांकेतिक चिन्ह का उत्पादन करेगा ।

template <int INDEX = 0, int ...D> struct Helper : Helper<INDEX + 1, D..., INDEX * INDEX> {
};
template<> struct Helper<0, <>> : Helper<0 + 1, 0 * 0> {
};
template<> struct Helper<1, <0>> : Helper<1 + 1, 0, 1 * 1> {
};
template<> struct Helper<2, <0, 1>> : Helper<2 + 1, 0, 1, 2 * 2> {
};
template<> struct Helper<3, <0, 1, 4>> : Helper<3 + 1, 0, 1, 4, 3 * 3> {
};
template<> struct Helper<4, <0, 1, 4, 9>> : Helper<4 + 1, 0, 1, 4, 9, 4 * 4> {
};
template<> struct Helper<5, <0, 1, 4, 9, 16>> : Helper<5 + 1, 0, 1, 4, 9, 16, 5 * 5> {
};
template<> struct Helper<6, <0, 1, 4, 9, 16, 25>> : Helper<6 + 1, 0, 1, 4, 9, 16, 25, 6 * 6> {
};
template<> struct Helper<7, <0, 1, 4, 9, 16, 25, 36>> : Helper<7 + 1, 0, 1, 4, 9, 16, 25, 36, 7 * 7> {
};
template<> struct Helper<8, <0, 1, 4, 9, 16, 25, 36, 49>> : Helper<8 + 1, 0, 1, 4, 9, 16, 25, 36, 49, 8 * 8> {
};
template<> struct Helper<9, <0, 1, 4, 9, 16, 25, 36, 49, 64>> : Helper<9 + 1, 0, 1, 4, 9, 16, 25, 36, 49, 64, 9 * 9> {
};
template<> struct Helper<10, <0, 1, 4, 9, 16, 25, 36, 49, 64, 81>> {
  static constexpr std::array<int, TABLE_SIZE> table = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81};
};

चूंकि सी ++ 17 इसे और अधिक आसानी से लिखा जा सकता है।

 
#include <iostream>
#include <array>

constexpr int TABLE_SIZE = 10;

constexpr std::array<int, TABLE_SIZE> table = [] { // OR: constexpr auto table
  std::array<int, TABLE_SIZE> A = {};
  for (unsigned i = 0; i < TABLE_SIZE; i++) {
    A[i] = i * i;
  }
  return A;
}();

enum  {
  FOUR = table[2] // compile time use
};

int main() {
  for (int i=0; i < TABLE_SIZE; i++) {
    std::cout << table[i]  << std::endl; // run time use
  }
  std::cout << "FOUR: " << FOUR << std::endl;
}

अधिक परिष्कृत उदाहरण दिखाने के लिए निम्नलिखित सूची में सांकेतिक चिन्ह को मूल्य गणना के लिए एक सहायक जटिल संगणना की तैयारी में तालिका विशिष्ट प्रतिसंतुलन और तालिका मानों के प्रकार के लिए एक नमूना तर्क के लिए विस्तारित किया गया है।

                                                                
#include <iostream>
#include <array>

constexpr int TABLE_SIZE = 20;
constexpr int OFFSET = 12;

/**
 * Template to calculate a single table entry
 */
template <typename VALUETYPE, VALUETYPE OFFSET, VALUETYPE INDEX>
struct ValueHelper {
  static constexpr VALUETYPE value = OFFSET + INDEX * INDEX;
};

/**
 * Variadic template for a recursive helper struct.
 */
template<typename VALUETYPE, VALUETYPE OFFSET, int N = 0, VALUETYPE ...D>
struct Helper : Helper<VALUETYPE, OFFSET, N+1, D..., ValueHelper<VALUETYPE, OFFSET, N>::value> { };

/**
 * Specialization of the template to end the recursion when the table size reaches TABLE_SIZE.
 */
template<typename VALUETYPE, VALUETYPE OFFSET, VALUETYPE ...D>
struct Helper<VALUETYPE, OFFSET, TABLE_SIZE, D...> {
  static constexpr std::array<VALUETYPE, TABLE_SIZE> table = { D... };
};

constexpr std::array<uint16_t, TABLE_SIZE> table = Helper<uint16_t, OFFSET>::table;

int main() {
  for (int i = 0; i < TABLE_SIZE; i++) {
    std::cout << table[i] << std::endl;
  }
}

जिसे C++17 का उपयोग करके इस प्रकार लिखा जा सकता है:

#include <iostream>
#include <array>

constexpr int TABLE_SIZE = 20;
constexpr int OFFSET = 12;

template<typename VALUETYPE, VALUETYPE OFFSET>
constexpr std::array<VALUETYPE, TABLE_SIZE> table = [] { // OR: constexpr auto table
  std::array<VALUETYPE, TABLE_SIZE> A = {};
  for (unsigned i = 0; i < TABLE_SIZE; i++) {
    A[i] = OFFSET + i * i;
  }
  return A;
}();

int main() {
  for (int i = 0; i < TABLE_SIZE; i++) {
    std::cout << table<uint16_t, OFFSET>[i] << std::endl;
  }
}

अवधारणाएं

C++20 मानक ने C++ कार्यक्रमों को मेटा नमूना कार्यक्रम की अवधारणाओं के लिए एक नया उपकरण दिया ^[4]अवधारणाएँ C++ कार्यक्रम के लिए आवश्यकताओं को निर्दिष्ट करने की अनुमति देती हैं जिससे नमूने का संस्थान संभव हो सके जो अवधारणा वाले नमूने की तलाश करता है जिसकी उच्चतम आवश्यकताएं हैं।

यहाँ नमूना मेटा प्रोग्रामिंग के साथ हल की गई प्रसिद्ध फ़िज़ भनभनाने की समस्या का एक उदाहरण है।

#include <boost/type_index.hpp> // for pretty printing of types
#include <iostream>
#include <tuple>

/**
 * Type representation of words to print
 */
struct Fizz {};
struct Buzz {};
struct FizzBuzz {};
template<size_t _N> struct number { constexpr static size_t N = _N; };

/**
 * Concepts used to define condition for specializations
 */
template<typename Any> concept has_N = requires{ requires Any::N - Any::N == 0; };
template<typename A> concept fizz_c = has_N<A> && requires{ requires A::N % 3 == 0; };
template<typename A> concept buzz_c = has_N<A> && requires{ requires A::N % 5 == 0;};
template<typename A> concept fizzbuzz_c = fizz_c<A> && buzz_c<A>;

/**
 * By specializing `res` structure, with concepts requirements, proper instantiation is performed
 */
template<typename X> struct res;
template<fizzbuzz_c X> struct res<X> { using result = FizzBuzz; };
template<fizz_c X> struct res<X> { using result = Fizz; };
template<buzz_c X> struct res<X> { using result = Buzz; };
template<has_N X> struct res<X> { using result = X; };

/**
 * Predeclaration of concatenator
 */
template <size_t cnt, typename... Args> 
struct concatenator;

/**
 * Recursive way of concatenating next types
 */
template <size_t cnt, typename ... Args>
struct concatenator<cnt, std::tuple<Args...>> 
{ using type = typename concatenator<cnt - 1, std::tuple< typename res< number<cnt> >::result, Args... >>::type;};

/**
 * Base case
 */
template <typename... Args> struct concatenator<0, std::tuple<Args...>> { using type = std::tuple<Args...>;};

/**
 * Final result getter
 */
template<size_t Amount>
using fizz_buzz_full_template = typename concatenator<Amount - 1, std::tuple<typename res<number<Amount>>::result>>::type;

int main()
{
	// printing result with boost, so it's clear
	std::cout << boost::typeindex::type_id<fizz_buzz_full_template<100>>().pretty_name() << std::endl;
/*
Result:
	std::tuple<number<1ul>, number<2ul>, Fizz, number<4ul>, Buzz, Fizz, number<7ul>, number<8ul>, Fizz, Buzz, number<11ul>, Fizz, number<13ul>, number<14ul>, FizzBuzz, number<16ul>, number<17ul>, Fizz, number<19ul>, Buzz, Fizz, number<22ul>, number<23ul>, Fizz, Buzz, number<26ul>, Fizz, number<28ul>, number<29ul>, FizzBuzz, number<31ul>, number<32ul>, Fizz, number<34ul>, Buzz, Fizz, number<37ul>, number<38ul>, Fizz, Buzz, number<41ul>, Fizz, number<43ul>, number<44ul>, FizzBuzz, number<46ul>, number<47ul>, Fizz, number<49ul>, Buzz, Fizz, number<52ul>, number<53ul>, Fizz, Buzz, number<56ul>, Fizz, number<58ul>, number<59ul>, FizzBuzz, number<61ul>, number<62ul>, Fizz, number<64ul>, Buzz, Fizz, number<67ul>, number<68ul>, Fizz, Buzz, number<71ul>, Fizz, number<73ul>, number<74ul>, FizzBuzz, number<76ul>, number<77ul>, Fizz, number<79ul>, Buzz, Fizz, number<82ul>, number<83ul>, Fizz, Buzz, number<86ul>, Fizz, number<88ul>, number<89ul>, FizzBuzz, number<91ul>, number<92ul>, Fizz, number<94ul>, Buzz, Fizz, number<97ul>, number<98ul>, Fizz, Buzz>
*/
}

नमूने में मेटाप्रोग्रामिंग के लाभ और कमियां

कंपाइल समय बनाम निष्पादन समय व्यापार: यदि नमूना मेटाप्रोग्रामिंग का उपयोग किया जाता है।
सामान्य प्रोग्रामिंग: नमूना मेटाप्रोग्रामिंग कार्यकर्ता को आभाषी पर ध्यान केंद्रित करने और ग्राहक चिन्ह द्वारा आवश्यक किसी भी कार्यान्वयन की पीढ़ी को कंपाइलर को सौंपने की अनुमति देता है इस प्रकार नमूना मेटाप्रोग्रामिंग वास्तव में सामान्य चिन्ह को पूरा कर सकता है जिससे सांकेतिक चिन्ह न्यूनीकरण और बेहतर रखरखाव की सुविधा मिलती है।^{[citation needed]}.
पठनीयता: C++ 11 से पहले C++ के संबंध में नमूना मेटाप्रोग्रामिंग के वाक्य-विन्यास और मुहावरे पारंपरिक C++ कार्यक्रमों की तुलना में गूढ़ थे और नमूना मेटाप्रोग्राम को समझना बहुत मुश्किल हो सकता है ^[5]^[6] लेकिन सी ++ 11 से आगे मूल्य गणना मेटाप्रोग्रामिंग के लिए कम पठनीयता दंड के साथ सामान्य सी ++ के समान अधिक हो जाता है।

यह भी देखें

प्रतिस्थापन विफलता एक त्रुटि नहीं है।
मेटाप्रोग्रामिंग।
पूर्वप्रक्रमक।
प्राचलिक बहुरूपता।
अभिव्यक्ति नमूने।
वैराडिक नमूने।
संकलन समय कार्यक्रम निष्पादन।

संदर्भ

↑ Scott Meyers (12 May 2005). Effective C++: 55 Specific Ways to Improve Your Programs and Designs. Pearson Education. ISBN 978-0-13-270206-5.
↑ See History of TMP on Wikibooks
↑ Veldhuizen, Todd L. (2003). "C++ टेम्प्लेट ट्यूरिंग पूर्ण हैं". CiteSeerX 10.1.1.14.3670. {{cite journal}}: Cite journal requires |journal= (help)
↑ "Constraints and concepts (since C++20) - cppreference.com". en.cppreference.com.
↑ Czarnecki, K.; O'Donnell, J.; Striegnitz, J.; Taha, Walid Mohamed (2004). "DSL implementation in metaocaml, template haskell, and C++" (PDF). University of Waterloo, University of Glasgow, Research Centre Julich, Rice University. C++ Template Metaprogramming suffers from a number of limitations, including portability problems due to compiler limitations (although this has significantly improved in the last few years), lack of debugging support or IO during template instantiation, long compilation times, long and incomprehensible errors, poor readability of the code, and poor error reporting. {{cite journal}}: Cite journal requires |journal= (help)
↑ Sheard, Tim; Jones, Simon Peyton (2002). "Template Meta-programming for Haskell" (PDF). ACM 1-58113-415-0/01/0009. Robinson's provocative paper identifies C++ templates as a major, albeit accidental, success of the C++ language design. Despite the extremely baroque nature of template meta-programming, templates are used in fascinating ways that extend beyond the wildest dreams of the language designers. Perhaps surprisingly, in view of the fact that templates are functional programs, functional programmers have been slow to capitalize on C++'s success {{cite journal}}: Cite journal requires |journal= (help)

Eisenecker, Ulrich W. (2000). Generative Programming: Methods, Tools, and Applications. Addison-Wesley. ISBN 0-201-30977-7.
Alexandrescu, Andrei (2003). Modern C++ Design: Generic Programming and Design Patterns Applied. Addison-Wesley. ISBN 3-8266-1347-3.
Abrahams, David; Gurtovoy, Aleksey (January 2005). C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond. Addison-Wesley. ISBN 0-321-22725-5.
Vandevoorde, David; Josuttis, Nicolai M. (2003). C++ Templates: The Complete Guide. Addison-Wesley. ISBN 0-201-73484-2.
Clavel, Manuel (2000-10-16). Reflection in Rewriting Logic: Metalogical Foundations and Metaprogramming Applications. ISBN 1-57586-238-7.

बाहरी संबंध

"The Boost Metaprogramming Library (Boost MPL)".
"The Spirit Library". (built using template-metaprogramming)
"The Boost Lambda library". (use STL algorithms easily)
Veldhuizen, Todd (May 1995). "Using C++ template metaprograms". C++ Report. 7 (4): 36–43. Archived from the original on 2009-03-04.
"Template Haskell". (type-safe metaprogramming in Haskell)
Bright, Walter. "Templates Revisited". (template metaprogramming in the D programming language)
Koskinen, Johannes. "Metaprogramming in C++" (PDF).
Attardi, Giuseppe; Cisternino, Antonio. "Reflection support by means of template metaprogramming" (PDF).
Burton, Michael C.; Griswold, William G.; McCulloch, Andrew D.; Huber, Gary A. (2002). "Static data structures". CiteSeerX 10.1.1.14.5881. {{cite journal}}: Cite journal requires |journal= (help)
Amjad, Zeeshan (13 August 2007). "Template Meta Programming and Number Theory".
Amjad, Zeeshan (24 August 2007). "Template Meta Programming and Number Theory: Part 2".
"A library for LISP-style programming in C++".

[Meyers2005-1] Scott Meyers (12 May 2005). Effective C++: 55 Specific Ways to Improve Your Programs and Designs. Pearson Education. ISBN 978-0-13-270206-5.

[2] See History of TMP on Wikibooks

[Veldhuizen2003-3] Veldhuizen, Todd L. (2003). "C++ टेम्प्लेट ट्यूरिंग पूर्ण हैं". CiteSeerX 10.1.1.14.3670. {{cite journal}}: Cite journal requires |journal= (help)

[4] "Constraints and concepts (since C++20) - cppreference.com". en.cppreference.com.

[5] Czarnecki, K.; O'Donnell, J.; Striegnitz, J.; Taha, Walid Mohamed (2004). "DSL implementation in metaocaml, template haskell, and C++" (PDF). University of Waterloo, University of Glasgow, Research Centre Julich, Rice University. C++ Template Metaprogramming suffers from a number of limitations, including portability problems due to compiler limitations (although this has significantly improved in the last few years), lack of debugging support or IO during template instantiation, long compilation times, long and incomprehensible errors, poor readability of the code, and poor error reporting. {{cite journal}}: Cite journal requires |journal= (help)

[6] Sheard, Tim; Jones, Simon Peyton (2002). "Template Meta-programming for Haskell" (PDF). ACM 1-58113-415-0/01/0009. Robinson's provocative paper identifies C++ templates as a major, albeit accidental, success of the C++ language design. Despite the extremely baroque nature of template meta-programming, templates are used in fascinating ways that extend beyond the wildest dreams of the language designers. Perhaps surprisingly, in view of the fact that templates are functional programs, functional programmers have been slow to capitalize on C++'s success {{cite journal}}: Cite journal requires |journal= (help)

[1]

[2]

[3]

[4]

[5]

[6]

Anonymous

Search

टेम्पलेट मेटाप्रोग्रामिंग

Namespaces

More

Page actions

Contents