काल्पनिक, पूर्व-C++ 0x अवधारणाओं सवाल

Question

(प्रस्तावना: मैं कर रहा हूँ C++ 0x खेल और C++ 0x मानक से अवधारणाओं को हटाने के बारे में हाल ही में विवाद के लिए एक देर अनुयायी करने के लिए मुझे प्रेरित किया है उनके बारे में और जानें। जबकि मैं समझता हूं कि मेरे सभी प्रश्न पूरी तरह से कल्पित हैं - अवधारणाओं के रूप में कुछ समय आने के लिए अवधारणाएं वैध सी ++ कोड नहीं होंगी, अगर बिल्कुल - मुझे अभी भी अवधारणाओं के बारे में अधिक जानने में रुचि है, खासकर दिया है कि यह कैसे मुझे और अधिक पूरी तरह से हाल के निर्णय और विवाद है कि का पालन किया है)

पीछे गुण को समझने C++ 0x के रूप में अवधारणाओं (हाल ही में जब तक) उन्हें प्रस्तावित पर कुछ परिचयात्मक सामग्री को पढ़ने के होने के बाद मदद मिलेगी, मैं परेशानी हो रही हूँ कुछ मनोचिकित्सक के आसपास अपने दिमाग लपेटना मुद्दे। आगे के बिना, मेरे प्रश्न यहां दिए गए हैं:

1) क्या एक ऐसा प्रकार जो एक विशेष व्युत्पन्न अवधारणा का समर्थन करता है (या तो स्पष्ट रूप से, ऑटो कीवर्ड के माध्यम से, या स्पष्ट रूप से concept_maps के माध्यम से) को भी मूल अवधारणा का समर्थन करने की आवश्यकता है? दूसरे शब्दों में, किसी अन्य अवधारणा को प्राप्त करने का कार्य (उदा। concept B<typename T> : A<T>) में अंतर्निहित रूप से 'अदृश्य' की आवश्यकता है बयान (बी, requires A<T>; के भीतर)?

वर्ग विरासत में जैसा

, प्रकार है कि व्युत्पन्न अवधारणा की आवश्यकताओं को पूरा भी आधार अवधारणा की आवश्यकताओं को पूरा: भ्रम अवधारणाओं पर विकिपीडिया पृष्ठ जिसमें कहा गया है से उठता है।

ऐसा लगता है कि एक प्रकार को केवल व्युत्पन्न अवधारणा की आवश्यकताओं को पूरा करने की आवश्यकता है और आवश्यक रूप से मूल अवधारणा की आवश्यकताओं को पूरा करने की आवश्यकता नहीं है, जो मुझे कोई समझ नहीं आता है। मैं समझता हूं कि विकिपीडिया एक निश्चित स्रोत से बहुत दूर है; उपर्युक्त वर्णन सिर्फ शब्दों की एक खराब पसंद है?

2) क्या एक अवधारणा जो टाइपनामों को सूचीबद्ध करती है 'ऑटो' हो सकती है? यदि हां, तो कंपाइलर इन टाइपनामों को स्वचालित रूप से कैसे मैप करेगा? यदि नहीं, तो क्या कोई अन्य मौका है जहां एक अवधारणा पर 'ऑटो' का उपयोग करना अवैध होगा?

template<typename Type> 
class Dummy {}; 

class Dummy2 { public: typedef int Type; }; 

auto concept SomeType<typename T> 
{ 
    typename Type; 
} 

template<typename T> requires SomeType<T> 
void function(T t) 
{} 

int main() 
{ 
    function(Dummy<int>()); //would this match SomeType? 
    function(Dummy2()); //how about this? 
    return 0; 
} 

उन वर्गों में से या तो SomeType से मेल खाते हैं चाहेंगे:

स्पष्ट करने के लिए निम्न काल्पनिक कोड पर विचार? या टाइपनाम नाम से अवधारणाओं के लिए एक अवधारणा_मैप आवश्यक है?

3) अंत में, मुझे समझने में कठिनाई हो रही है कि कौन से सिद्धांतों को परिभाषित करने की अनुमति दी जाएगी। उदाहरण के लिए, मैं इस तरह के

concept SomeConcept<typename T> 
{ 
    T operator*(T&, int); 

    axiom Inconsistency(T a) 
    { 
     a * 1 == a * 2; 
    } 
} 

के रूप में है कि क्या करना होगा एक अवधारणा एक स्वयंसिद्ध जो तार्किक रूप से असंगत है परिभाषित हो सकता था? क्या यह भी वैध है?

मुझे सराहना है कि यह प्रश्नों का एक बहुत लंबा सेट है और इसलिए मैं आपको अग्रिम धन्यवाद देता हूं।

Answer 1

मैंने निम्नलिखित उत्तर के संदर्भ के रूप में हालिया सी ++ 0x ड्राफ्ट, N2914 (जो अभी भी इसमें शब्द बोल रहा है) का उपयोग किया है।

1) अवधारणाएं उसमें इंटरफेस की तरह हैं। यदि आपका प्रकार एक अवधारणा का समर्थन करता है, तो इसे सभी "आधार" अवधारणाओं का भी समर्थन करना चाहिए। विकिपीडिया कथन आपको उद्धरण एक प्रकार के क्लाइंट के दृष्टिकोण से समझ में आता है - अगर वह जानता है कि T अवधारणा Derived<T> को संतुष्ट करता है, तो वह यह भी जानता है कि यह अवधारणा Base<T> को संतुष्ट करता है। प्रकार लेखक परिप्रेक्ष्य से, यह स्वाभाविक रूप से मतलब है कि दोनों को लागू किया जाना है। 14.10.3/2 देखें।

2) हां, typename सदस्यों के साथ एक अवधारणा auto हो सकती है। ऐसे सदस्यों को स्वचालित रूप से कम किया जा सकता है यदि वे एक ही अवधारणा में फ़ंक्शन सदस्यों की परिभाषाओं में उपयोग किए जाते हैं। उदाहरण के लिए, इटरेटर के लिए value_type को operator* के रिटर्न प्रकार के रूप में घटाया जा सकता है। हालांकि, अगर किसी प्रकार का सदस्य कहीं भी उपयोग नहीं किया जाता है, तो इसे कम नहीं किया जाएगा, और इस प्रकार इसे स्पष्ट रूप से परिभाषित नहीं किया जाएगा। आपके उदाहरण में, या Dummy1 के लिए SomeType<T>::Type को कम करने का कोई तरीका नहीं है, क्योंकि Type अवधारणा के अन्य सदस्यों द्वारा उपयोग नहीं किया जाता है, इसलिए न तो कक्षा अवधारणा को मैप करेगी (और, वास्तव में, कोई वर्ग संभवतः ऑटो-मैप नहीं कर सकता इसे करने के लिए)। 14.10.1.2/11 और 14.10.2.2/4 देखें।

3) एक्सीम्स spec का एक कमजोर बिंदु था, और उन्हें लगातार कुछ (अधिक) समझने के लिए अद्यतन किया जा रहा था। मसौदे से अवधारणाओं को खींचने से ठीक पहले, paper था जो काफी बदल गया - इसे पढ़ें और देखें कि क्या यह आपके लिए अधिक समझ में आता है, या आपके पास अभी भी इसके बारे में प्रश्न हैं।

आपके विशिष्ट उदाहरण (वाक्य रचनात्मक अंतर के लिए लेखांकन) के लिए, इसका मतलब यह होगा कि कंप्रेसर को (a*1) को (a*2) के समान होने के लिए भाषा के "जैसा-अगर" नियम के उद्देश्य के लिए अनुमति दी जाएगी (यानी संकलक को इच्छित अनुकूलन करने की अनुमति है, जब तक परिणाम व्यवहार करता है जैसे कि कोई नहीं था)। हालांकि, संकलक किसी भी तरह से सिद्धांतों की शुद्धता को प्रमाणित करने के लिए आवश्यक नहीं है (इसलिए उन्हें एक्साइम्स क्यों कहा जाता है!) - यह उन्हें केवल उनके लिए ले जाता है।