C++: टेम्पलेट से स्ट्रिंग शाब्दिक पैदा

Question

template < unsigned int i > 
struct t { 
    static const char *s; 
}; 
template < unsigned int i > 
const char* t<i>::s = ...; 

जहां ... है पैरामीटर "0 1 2 ... मैं -1", उदाहरण के लिए "0 1 2 3 4" i == 5 के लिए के लिए।

क्या यह संभव है? (रन-टाइम पर ऐसा करने के लिए कोई समाधान नहीं है, कृपया!)

• जिज्ञासा से पूछे जाने वाले प्रश्न (प्रीप्रोसेसर मैक्रोज़/स्थिरांक के साथ ऐसा करना आसान होगा, लेकिन टेम्पलेट पैरामीटर के बारे में कैसे)?
• अर्थ है: संकलन-समय उत्पन्न स्ट्रिंग अक्षरशः। अब मुझे लगता है कि const इसे मजबूर नहीं करता है, लेकिन स्ट्रिंग पीढ़ी के लिए कोई रन-टाइम मूल्यांकन फ़ंक्शन ले सकता है।

Answer 1

नहीं, लेकिन यह संभव है:

template < unsigned int i > 
struct t { 
    static std::string s; 

    static std::string ConvertIntToString() 
    { 
    std::stringstream ss; 
    ss << i; 
    return ss.str(); 
    } 
}; 

template< unsigned int i > 
std::string t<i>::s = t<i>::ConvertIntToStr(); 

btw क्यों प्रयोग कर रहे हैं ग तार? सी ++ में std :: स्ट्रिंग क्लास है जो बेहतर है।

संपादित

मुझे लगता है कि आप टेम्पलेट विशेषज्ञता इस्तेमाल कर सकते हैं:

template < unsigned int i > 
struct t; 

template <> 
struct t<0> 
{ 
    static const char * const s; 
}; 
const char* const t<0>::s = "abc"; 

template <> 
struct t<1> 
{ 
    static const char * const s; 
}; 
const char* const t<1>::s = "123"; 

Answer 2

असंभव।

क्योंकि टेम्पलेट का विस्तार संकलन समय पर किया जाता है जब संकलक केवल स्थिर मूल्य से निपट सकता है, यह जानता है। मेमोरी आवंटन (उदाहरण के लिए एक स्ट्रिंग शुरू करना) से जुड़े किसी भी ऑपरेशन को इस समय संभव नहीं है लेकिन केवल रनटाइम पर भी संभव नहीं है।

Answer 3

यह टेम्पलेट का उपयोग करना संभव नहीं है। लेकिन stringstream का उपयोग करके, string बनाना छोटा है।

string makeit(int i) 
{ 
    stringstream sstr; 

    for (int x = 0; x < i-1; x++) 
     put x and ' ' in sstr; 
    put i in sstr; 
    return sstr contents converted to string 
} 

अधिक के बारे में stringstreamcan be found here जानकारी: यहाँ छद्म कोड है।

Answer 4

कोड आप प्रस्तुत कर रहे हैं, ...

template < unsigned int i > 
struct t { 
    static const char *s; 
}; 
static const char* t::s = ...; 

... अमान्य है। t::s में बाहरी संबंध होना चाहिए। इसके अलावा, परिभाषा को templated की जरूरत है।

कोड, जैसे के साथ सीधे समस्याओं फिक्सिंग ...

template < unsigned int i > 
struct T 
{ 
    static const char * const s; 
}; 

template< unsigned i > 
const char* const T<i>::s = ...; 

... तो किसी भी वांछित तार के साथ T<i>::s आरंभ तुच्छ है।

तो, अपने कोड में त्रुटियों को मॉड्यूल करें, जवाब है "हाँ, यह केवल संभव नहीं है, यह छोटा है"।

लेकिन आप इस रूबे गोल्डबर्ग योजना को एक छोटी सी चीज़ को पूरा करने के लिए क्यों चाहते हैं?

Answer 5

यह तकनीकी रूप से संभव है, यह बहुत ही बदसूरत है। यहां एक नमूना है जो एक हस्ताक्षरित int के लिए एक स्ट्रिंग अक्षर बनाता है। यह (1) 3 "i-1" फ़ॉर्म की एक स्ट्रिंग नहीं बनाता है, हालांकि मुझे यकीन है कि यदि आप प्रयास करने के इच्छुक हैं तो यह संभव है।

#include <iostream> 
#include <string> 
#include <limits> 

/////////////////////////////////////////////////////////////////////////////// 
// exponentiation calculations 
template <int accum, int base, int exp> struct POWER_CORE : POWER_CORE<accum * base, base, exp - 1>{}; 

template <int accum, int base> 
struct POWER_CORE<accum, base, 0> 
{ 
    enum : int { val = accum }; 
}; 

template <int base, int exp> struct POWER : POWER_CORE<1, base, exp>{}; 

/////////////////////////////////////////////////////////////////////////////// 
// # of digit calculations 
template <int depth, unsigned int i> struct NUM_DIGITS_CORE : NUM_DIGITS_CORE<depth + 1, i/10>{}; 

template <int depth> 
struct NUM_DIGITS_CORE<depth, 0> 
{ 
    enum : int { val = depth}; 
}; 

template <int i> struct NUM_DIGITS : NUM_DIGITS_CORE<0, i>{}; 

template <> 
struct NUM_DIGITS<0> 
{ 
    enum : int { val = 1 }; 
}; 

/////////////////////////////////////////////////////////////////////////////// 
// Convert digit to character (1 -> '1') 
template <int i> 
struct DIGIT_TO_CHAR 
{ 
    enum : char{ val = i + 48 }; 
}; 

/////////////////////////////////////////////////////////////////////////////// 
// Find the digit at a given offset into a number of the form 0000000017 
template <unsigned int i, int place> // place -> [0 .. 10] 
struct DIGIT_AT 
{ 
    enum : char{ val = (i/POWER<10, place>::val) % 10 }; 
}; 

struct NULL_CHAR 
{ 
    enum : char{ val = '\0' }; 
}; 

/////////////////////////////////////////////////////////////////////////////// 
// Convert the digit at a given offset into a number of the form '0000000017' to a character 
template <unsigned int i, int place> // place -> [0 .. 9] 
    struct ALT_CHAR : DIGIT_TO_CHAR< DIGIT_AT<i, place>::val >{}; 

/////////////////////////////////////////////////////////////////////////////// 
// Convert the digit at a given offset into a number of the form '17' to a character 

// Template description, with specialization to generate null characters for out of range offsets 
template <unsigned int i, int offset, int numDigits, bool inRange> 
    struct OFFSET_CHAR_CORE_CHECKED{}; 
template <unsigned int i, int offset, int numDigits>     
    struct OFFSET_CHAR_CORE_CHECKED<i, offset, numDigits, false> : NULL_CHAR{}; 
template <unsigned int i, int offset, int numDigits>     
    struct OFFSET_CHAR_CORE_CHECKED<i, offset, numDigits, true> : ALT_CHAR<i, (numDigits - offset) - 1 >{}; 

// Perform the range check and pass it on 
template <unsigned int i, int offset, int numDigits> 
    struct OFFSET_CHAR_CORE : OFFSET_CHAR_CORE_CHECKED<i, offset, numDigits, offset < numDigits>{}; 

// Calc the number of digits and pass it on 
template <unsigned int i, int offset> 
    struct OFFSET_CHAR : OFFSET_CHAR_CORE<i, offset, NUM_DIGITS<i>::val>{}; 

/////////////////////////////////////////////////////////////////////////////// 
// Integer to char* template. Works on unsigned ints. 
template <unsigned int i> 
struct IntToStr 
{ 
    const static char str[]; 
}; 

template <unsigned int i> 
const char IntToStr<i>::str[] = 
{ 
    OFFSET_CHAR<i, 0>::val, 
    OFFSET_CHAR<i, 1>::val, 
    OFFSET_CHAR<i, 2>::val, 
    OFFSET_CHAR<i, 3>::val, 
    OFFSET_CHAR<i, 4>::val, 
    OFFSET_CHAR<i, 5>::val, 
    OFFSET_CHAR<i, 6>::val, 
    OFFSET_CHAR<i, 7>::val, 
    OFFSET_CHAR<i, 8>::val, 
    OFFSET_CHAR<i, 9>::val, 
    NULL_CHAR::val 
}; 


/////////////////////////////////////////////////////////////////////////////// 
// Tests 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    std::wcout << IntToStr<17>::str << std::endl; 
    std::wcout << IntToStr<173457>::str << std::endl; 
    std::wcout << IntToStr<INT_MAX>::str << std::endl; 
    std::wcout << IntToStr<0>::str << std::endl; 
    std::wcout << IntToStr<1>::str << std::endl; 
    std::wcout << IntToStr<-1>::str << std::endl; 

    return 0; 
} 

Answer 6

मैं लगता है कि यह variadic टेम्पलेट के साथ संभव हो सकता है। मेरे पास परीक्षण करने के लिए एक कंपाइलर नहीं है, लेकिन मैं इस की लाइनों के साथ कुछ अनुमान लगा सकता हूं काम।

template < char ... RHS, unsigned int i> 
struct t { 
    static const char s[] = t<' ', char(i+'0'), RHS, i-1>::s; 
}; 

template <char ... RHS > 
struct t<RHS, 0> { 
    static const char s[] = {'0', RHS, '\0'}; 
}; 

void main() { 
    std::cout << t<5>::s; // {'0',' ','1',' ','2',' ','3',' ','4',' ','5','\0'} 
}