टाइप-रिच प्रोग्रामिंग

सम्मेलन देखने के बाद, GoingNative 2012 ने C ++ 11-शैली के कार्यक्रमों को लिखने के लिए "सर्वोत्तम अभ्यास" का वर्णन करने का प्रयास किया। जो लोग रुचि रखते हैं, उनके लिए लेखों की एक श्रृंखला की योजना बनाई गई है,
अक्सर, प्रोग्रामर एक इंटरफ़ेस का वर्णन करते हैं जो केवल उनके लिए समझ में आता है या विधि के स्रोत कोड को देखने के बाद स्पष्ट हो जाता है। यह बुरा है, अगर भयानक नहीं है। और यह सिर्फ विधि का नाम नहीं है।

खराब इंटरफेस के उदाहरणों की एक जोड़ी

void increase_speed(double); Rectangle(int,int,int,int); 

पहली नज़र में, ऐसा लगता है कि सबकुछ इतना बुरा नहीं है, लेकिन क्या आप इस सवाल का जवाब दे सकते हैं, कि क्या पैरामीटर को बढ़ाने के लिए पास किया जाना चाहिए? क्या गति में वृद्धि पैरामीटर पर निर्भर करती है? गति वृद्धि को किस इकाइयों में मापा जाता है?
4 मापदंडों के साथ एक आयत ctor के लिए, सामान्य तौर पर, सब कुछ जटिल है। क्या पैरामीटर आयत की ज्यामिति को इंगित करते हैं? क्या तीसरा पैरामीटर चौड़ाई या दूसरे बिंदु का x- समन्वय है? खैर, आदि।
इसके अलावा, जब अंतर्निहित प्रकारों के लिए बिल्ट-इन टाइप्स या टाइपेडिफ्स का उपयोग किया जाता है, तो हम increase_speed नहीं लिख पाएंगे, जो कि m / s में एक पैरामीटर लेता है और increase_speed का दूसरा संस्करण, जो किमी / घंटा लेता है। अंतर्निहित प्रकारों का उपयोग करते समय, यह एक ही फ़ंक्शन बढ़ेगा_स्पीड (डबल)।

बेहतर विकल्प

 void increase_speed(Speed); //         Rectangle(Point topLeft, BoxWH b); // ,           . 

पहले से ही बुरा नहीं है, लेकिन विभिन्न इकाइयों के लिए इकाइयों और ओवरलोडिंग कार्यों के साथ एक समस्या बनी हुई है। आइए एसआई प्रणाली में सभी मूल्यों को व्यक्त करने के लिए सहमत होते हैं और संकलन चरण पर इकाइयों की जांच करने के लिए संकलक प्राप्त करने का प्रयास करते हैं।

बचत जानकारी

हमें निम्नलिखित टेम्प्लेट क्लास की आवश्यकता होगी, जिसमें माप (मीटर, किलोग्राम, सेकंड) की संगत बुनियादी इकाइयों के लिए डिग्री होगी।

 template<int M, int K, int S> class Unit { //   () public: enum { m = M, kg = K, s = S }; }; 

ऐसे टेम्पलेट वर्ग का उपयोग करके सभी मान संग्रहीत किए जाएंगे:

 template<typename Unit> struct Value { double val; // explicit Value(double d) : val(d) {} public: /* * -    */ static constexpr int m() {return Unit::m;}; static constexpr int kg() {return Unit::kg;}; static constexpr int s() {return Unit::s;}; }; typedef Value<Unit<1, 0, -1> > Speed; //  = / typedef Value<Unit<1, 0, -2> > Acceleration; //  = // typedef Unit<1, 0, 0> M; typedef Unit<0, 0, 1> S; 

उपयोग उदाहरण:

 Acceleration acc1 = Value<Unit<1, 0, -2> >(2); //  = 2 //.  . Acceleration acc2 = Value<M >(2); //  . Speed sp1 = Value<Unit<1, 0, -2> >(2); //  . Speed sp2 = Value<Unit<1, 0, -1> >(2); //  = 2 /.  . 

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

यूनिट डिवीजन ऑपरेटर

 template<class Value1, class Value2> auto operator/(Value1 v1, Value2 v2) -> Value<Unit<Value1::m() - Value2::m(), Value1::kg() - Value2::kg(), Value1::s() - Value2::s()> > { return Value<Unit<Value1::m() - Value2::m(), Value1::kg() - Value2::kg(), Value1::s() - Value2::s()> >(v1.val / v2.val); 

अब हम इस प्रकार मानों को शुरू कर सकते हैं:

 Acceleration acc = Value<M>(100) / Value<S>(10) / Value<S>(1); //  = 10 //.  . Speed sp = Value<M>(100) / Value<S>(20); //  = 5 /.  . 

निष्कर्ष

क्या महत्वपूर्ण है, जाँच इकाइयों की इस तकनीक के साथ एक उपरि नहीं होना चाहिए, सभी जाँच संकलन अवस्था में की जाती हैं। गति को किमी / घंटा से एम / एस में बदलने के लिए, आपको फॉर्म का एक फ़ंक्शन लिखना होगा:

 Speed convertSpeed(KmPerHour val); 

, जहां KmPerHour वर्ग, प्राथमिक वर्ग है जिसे कन्वर्टस्पीड फ़ंक्शन के अधिभार को व्यवस्थित करने की आवश्यकता है। जितना संभव हो उतने अनूठे वर्गों का उपयोग करें, यह फ़ंक्शन ओवरलोडिंग का उपयोग करने में मदद करेगा और आपको वैचारिक रूप से समान संचालन (ConvertSpeed ​​(KmPerHour) और ConvertSpeed ​​(KmPerSec) के लिए अलग-अलग नामों का उपयोग करने से बचाएगा।
कोड को gcc 4.6.3 पर चेक किया गया था।

पुनश्च: मानक उपयोगकर्ता-परिभाषित शाब्दिक प्रदान करता है (संस्करण 4.7 से gcc में), जो निम्न के बारे में रिकॉर्डिंग को कम करेगा:

 Speed sp =100m/20s; //    operator"" s(double)  operator"" d(double). 

आपका ध्यान देने के लिए धन्यवाद।

अद्यतन: लेख का मुख्य संदेश आपके कार्यों में उत्तीर्ण मापदंडों के लिए कक्षाएं लिखने के लिए आलसी होना नहीं है और संकलन चरण में जितना संभव हो उतना जांचें।