फ़ंक्शनों से डिज़ाइन

क्रमिक परिशोधन

समस्या के कथन से कुछ पंक्तियों वाले main तक

इकाई 4 के प्रोग्राम पूरे के पूरे main के भीतर लिखे गए थे। जब तक वे एक स्क्रीन में समा जाते हैं, यह सहा जा सकता है; परंतु इस तरह लिखा गया दो सौ पंक्तियों का प्रोग्राम माँग करता है कि सब कुछ एक साथ दिमाग़ में रखा जाए, और वह केवल पूरे का परीक्षण स्वीकार करता है। क्रमिक परिशोधन, या ऊपर से नीचे का डिज़ाइन, काम का क्रम उलट देता है: पहले समस्या की भाषा में लिखा जाता है कि प्रोग्राम क्या करता है, ऐसे फ़ंक्शनों की कॉलों के अनुक्रम के रूप में जो अभी मौजूद नहीं हैं; फिर उनमें से हर फ़ंक्शन को एक नई, छोटी समस्या माना जाता है, और प्रक्रिया तब तक दोहराई जाती है जब तक इतने सरल फ़ंक्शन न मिल जाएँ कि उनकी बॉडी कुछ भी विघटित किए बिना लिखी जा सके।

उदाहरण के लिए यह समस्या लें। पूर्णांक $n \geq 1$ पूर्ण कहलाता है यदि उसके उचित भाजकों (वे धनात्मक भाजक जो $n$ से भिन्न हैं) का योग $n$ के बराबर हो, न्यून यदि योग छोटा हो और प्रचुर यदि बड़ा हो: $28 = 1 + 2 + 4 + 7 + 14$, अतः 28 पूर्ण है; 8, जिसके लिए $1 + 2 + 4 = 7$, न्यून है; 12, जिसके लिए $1 + 2 + 3 + 4 + 6 = 16$, प्रचुर है। ऐसा प्रोग्राम चाहिए जो $n$ पढ़े और उसके उचित भाजकों का योग और उसकी श्रेणी लिखे। डिज़ाइन का पहला स्तर main है, और वह सबसे पहले लिखा जाता है:

#include <cstdint>#include <iostream>#include <print>#include <string>​enum class Kind { deficient, perfect, abundant };​// n के धनात्मक भाजकों का योग।// पूर्व-शर्त: n >= 1।// पश्च-शर्त: n के सभी धनात्मक भाजकों का योग लौटाता है, n समेत।std::int64_t divisorSum(int n);​// उचित भाजकों के योग के अनुसार n की श्रेणी।// पूर्व-शर्त: n >= 1।// पश्च-शर्त: योग n से छोटा, बराबर या बड़ा होने के अनुसार deficient, perfect या abundant लौटाता है।Kind classify(int n);​// किसी श्रेणी का नाम, उसे लिखने के लिए।// पूर्व-शर्त: कोई नहीं।// पश्च-शर्त: “न्यून”, “पूर्ण” या “प्रचुर” लौटाता है।std::string kindName(Kind kind);​int main(){    int n{};    std::cin >> n;    std::println("{} के उचित भाजक: योग {}", n, divisorSum(n) - n);    std::println("{} एक {} संख्या है", n, kindName(classify(n)));}

/usr/bin/x86_64-linux-gnu-ld.bfd: main.o: in function `main':main.cpp:27:(.text+0x22a): undefined reference to `divisorSum(int)'/usr/bin/x86_64-linux-gnu-ld.bfd: main.cpp:28:(.text+0x3fd): undefined reference to `classify(int)'/usr/bin/x86_64-linux-gnu-ld.bfd: main.cpp:28:(.text+0x40d): undefined reference to `kindName[abi:cxx11](Kind)'collect2: error: ld returned 1 exit status

प्रोग्राम बिना किसी चेतावनी के कंपाइल होता है, क्योंकि हर कॉल अपनी घोषणा से मेल खाती है, और कंपाइलर केवल यही जाँचता है, जैसा पाठ फ़ंक्शन ने सिखाया। विफल होती है लिंकिंग: लिंकर परिभाषाएँ खोजता है और उन्हें नहीं पाता (“undefined reference”, यानी बिना परिभाषा का संदर्भ; जुड़ा हुआ [abi:cxx11] वह आंतरिक चिह्न है जो GCC उन फ़ंक्शनों पर लगाता है जो std::string लौटाते हैं)। यह स्थिति ठीक वही है जो इस बिंदु पर डिज़ाइन की स्थिति है: इंटरफ़ेस तय हो चुके हैं, बॉडी नहीं। यदि ऐसा है, तो main अभी से प्रोग्राम के विनिर्देश की तरह पढ़ा जाता है, और तीन घोषणाएँ बाक़ी काम हैं, हर एक आरंभिक समस्या से छोटा।

विघटन वृक्ष

दूसरा स्तर हर घोषणा में उतरता है। kindName तीन स्थितियों वाला निर्णय है। classify divisorSum पर टिका है: कोई संख्या पूर्ण होती है जब उसके सभी भाजकों का योग $2n$ हो। और divisorSum भाजकों को $(d, n/d)$ के जोड़ों में खोजने वाला लूप है, जो पाठ संख्यात्मक एल्गोरिदम से आता है और $\sqrt{n}$ पर रुकता है। परिणाम को वृक्ष के रूप में बनाया जाता है: जड़ पूरी समस्या है; हर नोड की संतानें वे उपसमस्याएँ हैं जो उसे हल करती हैं; पत्तियाँ वे संक्रियाएँ हैं जो भाषा पहले से देती है।

वृक्ष पूरा होने पर परिभाषाएँ नीचे से ऊपर की ओर लिखी जाती हैं, ताकि हर फ़ंक्शन पहले से लिखे फ़ंक्शनों पर टिके:

#include <cstdint>#include <iostream>#include <print>#include <string>​enum class Kind { deficient, perfect, abundant };​// n के धनात्मक भाजकों का योग।// पूर्व-शर्त: n >= 1।// पश्च-शर्त: n के सभी धनात्मक भाजकों का योग लौटाता है, n समेत।std::int64_t divisorSum(int n){    std::int64_t sum{0};    for (int d{1}; d <= n / d; ++d) {        if (n % d == 0) {            sum += d;            if (d != n / d) {                sum += n / d;            }        }    }    return sum;}​// उचित भाजकों के योग के अनुसार n की श्रेणी।// पूर्व-शर्त: n >= 1।// पश्च-शर्त: योग n से छोटा, बराबर या बड़ा होने के अनुसार deficient, perfect या abundant लौटाता है।Kind classify(int n){    const std::int64_t proper{divisorSum(n) - n};    if (proper < n) {        return Kind::deficient;    }    if (proper == n) {        return Kind::perfect;    }    return Kind::abundant;}​// किसी श्रेणी का नाम, उसे लिखने के लिए।// पूर्व-शर्त: कोई नहीं।// पश्च-शर्त: “न्यून”, “पूर्ण” या “प्रचुर” लौटाता है।std::string kindName(Kind kind){    if (kind == Kind::deficient) {        return "न्यून";    }    if (kind == Kind::perfect) {        return "पूर्ण";    }    return "प्रचुर";}​int main(){    int n{};    std::cin >> n;    std::println("{} के उचित भाजक: योग {}", n, divisorSum(n) - n);    std::println("{} एक {} संख्या है", n, kindName(classify(n)));}

28

28 के उचित भाजक: योग 2828 एक पूर्ण संख्या है

परिणाम की तीन विशेषताएँ विधि के कारण हैं। पहली, नीचे का हिस्सा लिखते समय main नहीं बदला। दूसरी, योग std::int64_t के रूप में लौटाया जाता है (<cstdint> से, वह 64 बिट का पूर्णांक जिसका उपयोग पाठ पुनरावर्तन भी करता है), क्योंकि $n$ के लिए जो int के अधिकतम मान के निकट हो, उसके भाजकों का योग उस मान से अधिक हो सकता है, और इंटरफ़ेस में यह तय कर देना कॉल करने वाले सभी की रक्षा करता है। तीसरी, हर फ़ंक्शन अलग से जाँचा जाता है: divisorSum(28) को 56 देना चाहिए, divisorSum(1) को 1 और divisorSum(36) को 91, जहाँ जोड़ा $(6, 6)$ एक ही बार गिना जाता है; पाठ का अंतिम अनुभाग इन जाँचों को एक प्रोग्राम में बदल देता है।