कार्यान्वयन का नाम और परिणाम नाम

मैं जुलाई में इस पोस्ट को वापस लिखना चाहता था, लेकिन मैं नहीं कर सकता था, ओह विडंबना , तय करें कि इसे क्या कहा जाए। केपट ग्रेगरी की CppCon में बात के बाद ही मेरे मन में सफल शब्द आए, और अब मैं आपको बता सकता हूं कि फ़ंक्शन कैसे कॉल करें।

बेशक, ऐसे नाम हैं जो सूचना को बिल्कुल नहीं ले जाते हैं, जैसे कि int f(int x) । उन्हें भी उपयोग करने की आवश्यकता नहीं है, लेकिन यह उनके बारे में नहीं है। कभी-कभी ऐसा होता है कि ऐसा लगता है कि शीर्षक में जानकारी भरी हुई है, लेकिन इससे कोई लाभ नहीं है।

उदाहरण 1: std :: log2p1 ()

C ++ 20 में, बिट ऑपरेशंस के लिए कई नए फ़ंक्शंस हेडर में जोड़े गए, दूसरों में std::log2p1 । यह इस तरह दिखता है:

 int log2p1(int i) { if (i == 0) return 0; else return 1 + int(std::log2(x)); } 

अर्थात्, किसी भी प्राकृतिक संख्या के लिए, फ़ंक्शन अपने द्विआधारी लघुगणक प्लस 1 को लौटाता है, और 0 के लिए यह 0. लौटाता है और यह if / else ऑपरेटर के लिए एक स्कूल का कार्य नहीं है, यह वास्तव में एक उपयोगी चीज है - न्यूनतम संख्या बिट्स जिसमें यह मान फिट होगा। केवल फ़ंक्शन के नाम से इसके बारे में अनुमान लगाना लगभग असंभव है।

उदाहरण 2: एसटीडी :: आशीर्वाद ()

अब यह नाम के बारे में नहीं होगा

एक छोटा विषयांतर: C ++ में, सूचक अंकगणित केवल सरणी तत्वों के संकेत के साथ काम करता है। जो, सिद्धांत रूप में, तर्कसंगत है: सामान्य मामले में, पड़ोसी वस्तुओं का सेट अज्ञात है और "दस बाइट्स में चर के दाईं ओर कुछ भी हो सकता है"। यह असंदिग्ध रूप से अस्पष्ट व्यवहार है।

 int obj = 0; int* ptr = &obj; ++ptr; //   

लेकिन इस तरह का प्रतिबंध मौजूदा कोड की एक बड़ी मात्रा को अनिश्चित व्यवहार घोषित करता है। उदाहरण के लिए, यहाँ std::vector<T>::reserve() का एक सरलीकृत कार्यान्वयन है std::vector<T>::reserve() :

 void reserve(std::size_t n) { //      auto new_memory = (T*) ::operator new(n * sizeof(T)); //    … //   auto size = this->size(); begin_ = new_memory; //   end_ = new_memory + size; //     end_capacity_ = new_memory + n; //    } 

हमने मेमोरी आवंटित की है, सभी ऑब्जेक्ट्स को स्थानांतरित किया है, और अब यह सुनिश्चित करने का प्रयास करें कि पॉइंटर्स इंगित करें कि कहां जाना है। यहाँ केवल अंतिम तीन पंक्तियाँ अपरिभाषित हैं, क्योंकि उनमें सरणी के बाहर बिंदुओं पर अंकगणितीय संक्रियाएँ हैं!

बेशक, यह प्रोग्रामर नहीं है जिसे दोष देना है। समस्या सी ++ मानक के साथ ही है, जो कोड के इस स्पष्ट रूप से उचित टुकड़े को अपरिभाषित व्यवहार घोषित करता है। इसलिए, P0593 कुछ कार्यों को जोड़कर मानक को सही करने का सुझाव देता है (जैसे ::operator new और std::malloc ) आवश्यकतानुसार सरणियाँ बनाने की क्षमता। उनके द्वारा बनाए गए सभी बिंदु जादुई रूप से सरणियों के संकेत बन जाएंगे, और उनके साथ अंकगणितीय संचालन किया जा सकता है।

अभी भी नामों के बारे में नहीं, एक सेकंड रुको।

लेकिन कभी-कभी, मेमोरी के साथ काम करते समय पॉइंटर्स पर संचालन की आवश्यकता होती है, इनमें से एक फ़ंक्शन आवंटित नहीं किया गया था। उदाहरण के लिए, deallocate() फ़ंक्शन अनिवार्य रूप से मृत मेमोरी के साथ काम करता है, जिसमें कोई भी ऑब्जेक्ट नहीं होते हैं, लेकिन फिर भी क्षेत्र के सूचक और आकार को जोड़ना होगा। इस मामले के लिए, P0593 ने फ़ंक्शन std::bless(void* ptr, std::size_t n) (वहाँ एक और फ़ंक्शन था, जिसे bless भी कहा जाता है, लेकिन यह इसके बारे में नहीं है)। वास्तविक जीवन के भौतिक कंप्यूटर पर इसका कोई प्रभाव नहीं पड़ता है, लेकिन यह एक अमूर्त मशीन के लिए वस्तुओं का निर्माण करता है जो कि सूचक अंकगणितीय के उपयोग की अनुमति देगा।

नाम std::bless अस्थायी था।

तो, नाम।

कोलोन में, LEWG को इस समारोह के लिए एक नाम के साथ आने का काम दिया गया था। विकल्प implicitly_create_objects() और implicitly_create_objects_as_needed() प्रस्तावित थे, क्योंकि यह वही है जो फ़ंक्शन करता है।

मुझे ये विकल्प पसंद नहीं थे।

उदाहरण 3: std :: आंशिक_sort_copy ()

केट की प्रस्तुति से लिया गया उदाहरण

एक फ़ंक्शन std::sort , जो कंटेनर के तत्वों को std::sort करता है:

 std::vector<int> vec = {3, 1, 5, 4, 2}; std::sort(vec.begin(), vec.end()); // vec == {1, 2, 3, 4, 5} 

वहाँ भी है std::partial_sort , जो तत्वों के केवल भाग को std::partial_sort करता है:

 std::vector<int> vec = {3, 1, 5, 4, 2}; std::partial_sort(vec.begin(), vec.begin() + 3, vec.end()); // vec == {1, 2, 3, ?, ?} ( ...4,5,  ...5,4) 

और अभी भी std::partial_sort_copy , जो तत्वों का हिस्सा भी सॉर्ट करता है, लेकिन एक ही समय में पुराने कंटेनर नहीं बदलता है, लेकिन मानों को नए में स्थानांतरित करता है:

 const std::vector<int> vec = {3, 1, 5, 4, 2}; std::vector<int> out; out.resize(3); std::partial_sort_copy(vec.begin(), vec.end(), out.begin(), out.end()); // out == {1, 2, 3} 

केट का दावा है कि std::partial_sort_copy एक तथाकथित नाम है, और मैं उससे सहमत हूं।

कार्यान्वयन का नाम और परिणाम नाम

सूचीबद्ध नामों में से कोई भी, सख्ती से बोल रहा है, गलत : वे सभी पूरी तरह से वर्णन करते हैं कि फ़ंक्शन क्या करता है। std::log2p1() वास्तव में द्विआधारी लघुगणक की गणना करता है और इसमें एक जोड़ता है; implicitly_create_objects() अंतर्निहित रूप से ऑब्जेक्ट बनाता है, और std::partial_sort_copy() आंशिक रूप से कंटेनर को सॉर्ट करता है और परिणाम की प्रतिलिपि बनाता है। हालांकि, मुझे ये सभी नाम पसंद नहीं हैं, क्योंकि वे बेकार हैं ।

कोई भी प्रोग्रामर नहीं बैठता है और सोचता है कि "काश मैं बाइनरी लॉगरिदम ले सकता और इसे जोड़ सकता"। उसे यह जानने की जरूरत है कि दिए गए मूल्य कितने बिट्स फिट होंगे, और वह bit_width जैसी किसी चीज के लिए असफल रूप से डॉक खोजता है। जब तक वह लाइब्रेरी उपयोगकर्ता तक पहुंचता है, तब तक बाइनरी लॉगरिथम का इससे क्या लेना-देना है, उसने पहले ही अपना कार्यान्वयन लिख दिया (और सबसे अधिक संभावना है कि शून्य के लिए चेक छूट गया)। यहां तक ​​कि अगर std::log2p1 कोड में कुछ चमत्कार निकला, तो इस कोड को देखने वाले अगले को फिर से समझना चाहिए कि यह क्या है और इसकी आवश्यकता क्यों है। bit_width(max_value) को ऐसी समस्या नहीं होगी।

इसी तरह, किसी को भी "ऑब्जेक्ट बनाने के लिए" या "वेक्टर की कॉपी को आंशिक रूप से सॉर्ट करने" की आवश्यकता नहीं है - उन्हें मेमोरी को पुन: उपयोग करने या अवरोही क्रम में 5 सबसे बड़े मान प्राप्त करने की आवश्यकता है। कुछ recycle_storage() (जिसे नाम std::bless ) के रूप में भी सुझाया गया था और top_n_sorted() बहुत स्पष्ट होगा।

Kate शब्द std::partial_sort_copy() लिए कार्यान्वयन नाम का उपयोग करता है, लेकिन यह दो अन्य कार्यों के लिए भी उपयुक्त है। उनके नाम का कार्यान्वयन वास्तव में पूरी तरह से वर्णित है। यह सिर्फ उपयोगकर्ता को परिणाम के नाम की आवश्यकता है - वह फ़ंक्शन को कॉल करके क्या प्राप्त करता है। उसकी आंतरिक संरचना के लिए, वह परवाह नहीं करता है, वह सिर्फ बिट्स में आकार का पता लगाना चाहता है या स्मृति का पुन: उपयोग करता है।

अपने विनिर्देश के आधार पर एक फ़ंक्शन का नाम देने का मतलब है कि नीले रंग से बाहर लाइब्रेरी और उसके उपयोगकर्ता के बीच गलतफहमी पैदा करना। आपको हमेशा याद रखना चाहिए कि फ़ंक्शन का उपयोग कब और कैसे किया जाएगा।

लगता है कि कॉर्नियां, हां। लेकिन std::log2p1() देखते हुए, यह सभी के लिए स्पष्ट है। इसके अलावा, कभी-कभी यह इतना सरल नहीं होता है।

उदाहरण 4: std :: popcount ()

std::popcount() , जैसे std::log2p1() , C ++ 20 में इसे <bit> std::log2p1() <bit> जोड़ना प्रस्तावित है। और यह, ज़ाहिर है, एक राक्षसी रूप से बुरा नाम है। यदि आप नहीं जानते कि यह कार्य क्या करता है, तो अनुमान लगाना असंभव है। न केवल संक्षिप्त नाम भ्रमित है (नाम में पॉप है, लेकिन पॉप / पुश का इससे कोई लेना-देना नहीं है) - जनसंख्या की गणना को गिना जाना (जनसंख्या की गिनती? आबादी की संख्या?) भी मदद नहीं करता है।

दूसरी ओर, std::popcount() इस फ़ंक्शन के लिए आदर्श है क्योंकि इसे असेंबली इंस्ट्रक्शन पॉपकाउंट कहते हैं। यह केवल कार्यान्वयन का नाम नहीं है - यह इसका पूर्ण विवरण है।

हालाँकि, इस मामले में, भाषा डेवलपर्स और प्रोग्रामर के बीच की खाई उतनी बड़ी नहीं है। एक निर्देश जो एक द्विआधारी शब्द में इकाइयों की संख्या को गिना जाता है, साठ के दशक से एक पॉपकाउंट कहा जाता है। ऐसे व्यक्ति के लिए जो बिट संचालन के बारे में कुछ भी जानता है, ऐसा नाम बिल्कुल स्पष्ट है।

वैसे, एक अच्छा सवाल: क्या आप उन नामों के बारे में सोचते हैं जो शुरुआती लोगों के लिए सुविधाजनक हैं, या पुराने लोगों के लिए उन्हें परिचित छोड़ देते हैं?

हैप्पी एंड?

P1956 का सुझाव है कि नाम बदलना std::log2p1() to std::bit_width() । यह प्रस्ताव C ++ 20 में स्वीकार किए जाने की संभावना है। std::ceil2 और std::floor2 का नाम बदलकर क्रमशः std: bit_ceil () और std :: bit_floor () भी कर दिया जाएगा। उनके पुराने नाम भी बहुत नहीं थे, लेकिन अन्य कारणों से।

कोलोन में LEWG ने या तो implicitly_create_objects[_as_needed] चयन नहीं किया और न ही std::bless लिए नाम के रूप में recycle_storage std::bless । उन्होंने इस कार्य को मानक में शामिल नहीं करने का निर्णय लिया। एक ही प्रभाव स्पष्ट रूप से बाइट्स की एक सरणी बनाकर प्राप्त किया जा सकता है, इसलिए, वे कहते हैं, फ़ंक्शन की आवश्यकता नहीं है। मुझे यह पसंद नहीं है क्योंकि कॉलिंग std::recycle_storage() अधिक पठनीय होगा। एक और std::bless() अभी भी मौजूद है, लेकिन अब start_lifetime_as कहा जाता है। मुझे वह पसंद है। इसे C ++ 23 में जाना चाहिए।

बेशक, std::partial_sort_copy() अब नाम नहीं std::partial_sort_copy() - इस नाम के तहत यह 1998 में मानक वापस दर्ज किया गया था। लेकिन कम से कम std::log2p1 तय किया std::log2p1 , और यह बुरा नहीं है।

कार्यों के नाम के साथ आने में, आपको यह सोचने की आवश्यकता है कि उनका उपयोग कौन करेगा और वह उनसे क्या चाहता है। जैसा कि केट ने कहा था, नामकरण के लिए सहानुभूति की आवश्यकता है ।