C++
तकनीक को फिर से दिखाना

परिचय

फिर से चलना

यहां एक कार्यक्रम है जो कि रिफैक्टिंग से लाभान्वित हो सकता है। यह C ++ 11 का उपयोग करके एक सरल प्रोग्राम है, जिसका उद्देश्य 1 से 100 तक की सभी प्राइम संख्याओं की गणना और प्रिंट करना है और यह एक प्रोग्राम पर आधारित है जिसे समीक्षा के लिए CodeReview पर पोस्ट किया गया था।

#include <iostream>
#include <vector>
#include <cmath>

int main()
{
    int l = 100;
    bool isprime;
    std::vector<int> primes;
    primes.push_back(2);
    for (int no = 3; no < l; no += 2) {
        isprime = true;
        for (int primecount=0; primes[primecount] <= std::sqrt(no); ++primecount) {
            if (no % primes[primecount] == 0) {
                isprime = false;
                break;
            } else if (primes[primecount] * primes[primecount] > no) {
                std::cout << no << "\n";
                break;
            }
        }
        if (isprime) {
            std::cout << no << " ";
            primes.push_back(no);
        }
    }
    std::cout << "\n";
}

इस कार्यक्रम से उत्पादन इस तरह दिखता है:

३ ५ 43 ११ १३ १ 41 १ ९ १ ९ २३ ३ ९ ३ 41 ३ 7 ४१ ४३ ४३ ५६ ६ 73 ६ 73 79१ 83३ 97 ९ 97 ९। ९ 17 ९

पहली चीज जो हम देखते हैं, वह यह है कि कार्यक्रम 2 को प्रिंट करने में विफल रहता है जो कि एक प्रमुख संख्या है। एक है कि अभाज्य संख्या की सूची बनाता एक एक और है कि प्रिंट उन्हें - हम तो बस बस उस कार्यक्रम के बाकी को संशोधित किए बिना एक स्थिर, लेकिन यह neater हो सकता है दो भागों में विभाजित करने के लिए कार्यक्रम यह refactor करने के लिए मुद्रित करने के लिए कोड की एक पंक्ति जोड़ सकता है । यहाँ है कि कैसे लग सकता है:

#include <iostream>
#include <vector>
#include <cmath>

std::vector<int> prime_list(int limit)
{
    bool isprime;
    std::vector<int> primes;
    primes.push_back(2);
    for (int no = 3; no < limit; no += 2) {
        isprime = true;
        for (int primecount=0; primes[primecount] <= std::sqrt(no); ++primecount) {
            if (no % primes[primecount] == 0) {
                isprime = false;
                break;
            } else if (primes[primecount] * primes[primecount] > no) {
                break;
            }
        }
        if (isprime) {
            primes.push_back(no);
        }
    }
    return primes;
}

int main() 
{
    std::vector<int> primes = prime_list(100);
    for (std::size_t i = 0; i < primes.size(); ++i) {
        std::cout << primes[i] << ' ';
    }
    std::cout << '\n';
}

इस संस्करण की कोशिश करते हुए, हम देखते हैं कि यह वास्तव में अब सही ढंग से काम करता है:

२ ३ ५ 43 ११ १३ १ 5 १ ९ १ ९ २३ ३ ९ ३ 5 ३ 5 ४१ ४३ ४३ ५६ ६ 73 ६ 73 79१ 83३ 7 ९ 7 ९। ९। ९

अगला कदम यह देखना है कि दूसरा if क्लॉज की वास्तव में जरूरत नहीं है। लूप में तर्क उस संख्या के वर्गमूल तक प्रत्येक दिए गए संख्या के प्रमुख कारकों को देखता है। यह काम करता है क्योंकि यदि संख्या के किसी भी प्रमुख कारक हैं तो उनमें से कम से कम एक उस संख्या के वर्गमूल से कम या उसके बराबर होना चाहिए। केवल उस फ़ंक्शन का अनुक्रमण (कार्यक्रम का शेष भाग समान रहता है) हमें यह परिणाम मिलता है:

std::vector<int> prime_list(int limit)
{
    bool isprime;
    std::vector<int> primes;
    primes.push_back(2);
    for (int no = 3; no < limit; no += 2) {
        isprime = true;
        for (int primecount=0; primes[primecount] <= std::sqrt(no); ++primecount) {
            if (no % primes[primecount] == 0) {
                isprime = false;
                break;
            }
        }
        if (isprime) {
            primes.push_back(no);
        }
    }
    return primes;
}

हम आगे जा सकते हैं, परिवर्तनशील नामों को थोड़ा अधिक वर्णनात्मक बना सकते हैं। उदाहरण के लिए primecount वास्तव में primecount की गिनती नहीं है। इसके बजाय यह ज्ञात अपराधों के वेक्टर में एक सूचकांक चर है। इसके अलावा, जबकि कभी-कभी "नंबर" के लिए एक संक्षिप्त नाम के रूप में उपयोग no किया जाता है, गणितीय लेखन में, n का उपयोग करना अधिक सामान्य है। हम break को समाप्त करके, और चरों को घोषित करने के लिए कुछ संशोधन भी कर सकते हैं जहां वे उपयोग किए जाते हैं।

std::vector<int> prime_list(int limit)
{
    std::vector<int> primes{2};
    for (int n = 3; n < limit; n += 2) {
        bool isprime = true;
        for (int i=0; isprime && primes[i] <= std::sqrt(n); ++i) {
            isprime &= (n % primes[i] != 0);
        }
        if (isprime) {
            primes.push_back(n);
        }
    }
    return primes;
}

हम इसे थोड़ा सा बनाने के लिए "रेंज-फॉर" का उपयोग करने के लिए main को रिफ्लेक्टर कर सकते हैं:

int main() 
{
    std::vector<int> primes = prime_list(100);
    for (auto p : primes) {
        std::cout << p << ' ';
    }
    std::cout << '\n';
}

यह सिर्फ एक तरीका है जिससे रिफैक्टरिंग की जा सकती है। अन्य लोग अलग-अलग विकल्प चुन सकते हैं। हालांकि, रीफैक्टरिंग का उद्देश्य एक ही है, जो पठनीयता में सुधार करना है और संभवत: सुविधाओं को जोड़ने के बिना कोड का प्रदर्शन।

गोटो सफाई

C ++ कोड बेस में, जो C हुआ करता था, कोई पैटर्न goto cleanup पा सकता है। चूंकि goto कमांड किसी फ़ंक्शन के वर्कफ़्लो को समझने में कठिन बनाता है, इसलिए इसे अक्सर टाला जाता है। अक्सर, इसे रिटर्न स्टेटमेंट, लूप, फ़ंक्शंस द्वारा प्रतिस्थापित किया जा सकता है। हालांकि, goto cleanup एक सफाई तर्क से छुटकारा पाने की जरूरत है।

short calculate(VectorStr **data) {
    short result = FALSE;
    VectorStr *vec = NULL;
    if (!data)
       goto cleanup;  //< Could become return false

    // ... Calculation which 'new's VectorStr

    result = TRUE;
cleanup:
    delete [] vec;
    return result;
}

C ++ में कोई भी इस समस्या को ठीक करने के लिए RAII का उपयोग कर सकता है:

struct VectorRAII final {
    VectorStr *data{nullptr};
    VectorRAII() = default;
    ~VectorRAII() {
        delete [] data;
    }
    VectorRAII(const VectorRAII &) = delete;
};

short calculate(VectorStr **data) {
    VectorRAII vec{};
    if (!data)
       return FALSE;  //< Could become return false

    // ... Calculation which 'new's VectorStr and stores it in vec.data

    return TRUE;
}

इस बिंदु से, कोई वास्तविक कोड को फिर से जारी कर सकता है। उदाहरण के लिए, VectorRAII द्वारा std::vector जगह VectorRAII से std::unique_ptr या std::vector ।