वृद्धिशील बयान के अपवाद के साथ लूप चर कास्ट के लिए कैसे करें?

Question 1

लूप के लिए एक मानक पर विचार करें:

for (int i = 0; i < 10; ++i) 
{
   // do something with i
}

मैं चर iको forलूप के शरीर में संशोधित होने से रोकना चाहता हूं ।

हालांकि, मैं घोषणा नहीं कर सकते हैं iके रूप में constके रूप में इस वेतन वृद्धि बयान अमान्य बना देता है। क्या वेतन वृद्धि वक्तव्य के बाहर iएक constचर बनाने का एक तरीका है ?

Question 2

C ++ 20 से, आप श्रेणियों का उपयोग कर सकते हैं :: विचार :: iota इस तरह:

for (int const i : std::views::iota(0, 10))
{
   std::cout << i << " ";  // ok
   i = 42;                 // error
}

यहाँ एक डेमो है ।

C ++ 11 से, आप निम्न तकनीक का भी उपयोग कर सकते हैं, जिसमें एक IIILE का उपयोग किया जाता है (तुरंत इनवॉल्ड लैम्बडा एक्सप्रेशन)

int x = 0;
for (int i = 0; i < 10; ++i) [&,i] {
    std::cout << i << " ";  // ok, i is readable
    i = 42;                 // error, i is captured by non-mutable copy
    x++;                    // ok, x is captured by mutable reference
}();     // IIILE

यहाँ एक डेमो है ।

ध्यान दें कि [&,i]इसका मतलब है कि iगैर-उत्परिवर्तित प्रतिलिपि द्वारा कैप्चर किया गया है, और बाकी सब कुछ उत्परिवर्तित संदर्भ द्वारा कैप्चर किया गया है। ();पाश के अंत में का अर्थ है कि लैम्ब्डा तुरंत शुरू हो जाती है।

Question 3

किसी के लिए जो कि Cigien का std::views::iotaजवाब पसंद करता है, लेकिन C ++ 20 या इसके बाद के संस्करण में काम नहीं कर रहा है, यह std::views::iotaसंगत के सरलीकृत और हल्के लागू करने के लिए सीधा हैc ++ 11 या ऊपर।

इसकी आवश्यकता है:

एक मूल " LegacyInputIterator " प्रकार (कुछ ऐसा जो परिभाषित करता है operator++और operator*) जो एक अभिन्न मूल्य (जैसे एक int) को लपेटता है
कुछ "रेंज" जैसी श्रेणी जिसके पास है begin()और end()जो उपरोक्त पुनरावृत्तियों को लौटाता है। यह इसे रेंज-आधारित forलूप में काम करने की अनुमति देगा

इसका एक सरलीकृत संस्करण हो सकता है:

#include <iterator>

// This is just a class that wraps an 'int' in an iterator abstraction
// Comparisons compare the underlying value, and 'operator++' just
// increments the underlying int
class counting_iterator
{
public:
    // basic iterator boilerplate
    using iterator_category = std::input_iterator_tag;
    using value_type = int;
    using reference  = int;
    using pointer    = int*;
    using difference_type = std::ptrdiff_t;

    // Constructor / assignment
    constexpr explicit counting_iterator(int x) : m_value{x}{}
    constexpr counting_iterator(const counting_iterator&) = default;
    constexpr counting_iterator& operator=(const counting_iterator&) = default;

    // "Dereference" (just returns the underlying value)
    constexpr reference operator*() const { return m_value; }
    constexpr pointer operator->() const { return &m_value; }

    // Advancing iterator (just increments the value)
    constexpr counting_iterator& operator++() {
        m_value++;
        return (*this);
    }
    constexpr counting_iterator operator++(int) {
        const auto copy = (*this);
        ++(*this);
        return copy;
    }

    // Comparison
    constexpr bool operator==(const counting_iterator& other) const noexcept {
        return m_value == other.m_value;
    }
    constexpr bool operator!=(const counting_iterator& other) const noexcept {
        return m_value != other.m_value;
    }
private:
    int m_value;
};

// Just a holder type that defines 'begin' and 'end' for
// range-based iteration. This holds the first and last element
// (start and end of the range)
// The begin iterator is made from the first value, and the
// end iterator is made from the second value.
struct iota_range
{
    int first;
    int last;
    constexpr counting_iterator begin() const { return counting_iterator{first}; }
    constexpr counting_iterator end() const { return counting_iterator{last}; }
};

// A simple helper function to return the range
// This function isn't strictly necessary, you could just construct
// the 'iota_range' directly
constexpr iota_range iota(int first, int last)
{
    return iota_range{first, last};
}

मैंने ऊपर constexprजहां यह समर्थित है, के साथ परिभाषित किया है, लेकिन C ++ 11/14 जैसे C ++ के पुराने संस्करणों के लिए, आपको constexprयह हटाने की आवश्यकता हो सकती है कि ऐसा करने के लिए उन संस्करणों में कानूनी नहीं है।

उपरोक्त बॉयलरप्लेट प्री-सी ++ 20 में काम करने के लिए निम्नलिखित कोड को सक्षम करता है:

for (int const i : iota(0, 10))
{
   std::cout << i << " ";  // ok
   i = 42;                 // error
}

जो अनुकूलित होने पर C ++ 20 समाधान और क्लासिक- लूप समाधान के समान विधानसभा उत्पन्न करेगा ।std::views::iotafor

यह किसी भी C ++ 11-कंपाइलर कंपाइलर (जैसे कंपाइलर gcc-4.9.4) के साथ काम करता है और फिर भी एक बेसिक- क्लोजर समकक्ष के लिए लगभग समान असेंबली का उत्पादन करता forहै।

नोट:iota सहायक समारोह सिर्फ सी ++ 20 के साथ सुविधा समता के लिए है std::views::iotaसमाधान; लेकिन वास्तविक रूप से, आप iota_range{...}कॉल करने के बजाय सीधे निर्माण भी कर सकते हैं iota(...)। यदि उपयोगकर्ता भविष्य में C ++ 20 पर स्विच करना चाहता है तो पूर्व केवल एक आसान अपग्रेड पथ प्रस्तुत करता है।

Question 4

KISS संस्करण ...

for (int _i = 0; _i < 10; ++_i) {
    const int i = _i;

    // use i here
}

यदि आपका उपयोग मामला सिर्फ लूप इंडेक्स के आकस्मिक संशोधन को रोकने के लिए है, तो इस तरह के बग को स्पष्ट करना चाहिए। (यदि आप जानबूझकर संशोधन, अच्छी तरह से, सौभाग्य को रोकना चाहते हैं ...)

Question 5

क्या आप किसी फंक्शन में लूप के लिए अपने या अपने कंटेंट की सभी सामग्री को स्थानांतरित नहीं कर सकते हैं जो मुझे एक कास्ट के रूप में स्वीकार करता है?

प्रस्तावित कुछ समाधानों की तुलना में इसकी कम इष्टतम है, लेकिन यदि संभव हो तो यह करना काफी सरल है।

संपादित करें: जैसा कि मैं स्पष्ट नहीं कर रहा हूँ बस एक उदाहरण है।

for (int i = 0; i < 10; ++i) 
{
   looper( i );
}

void looper ( const int v )
{
    // do your thing here
}

Question 6

यदि आपके पास पहुंच नहीं है c ++ 20, एक समारोह का उपयोग कर विशिष्ट बदलाव

#include <vector>
#include <numeric> // std::iota

std::vector<int> makeRange(const int start, const int end) noexcept
{
   std::vector<int> vecRange(end - start);
   std::iota(vecRange.begin(), vecRange.end(), start);
   return vecRange;
}

अब आप कर सकते हैं

for (const int i : makeRange(0, 10))
{
   std::cout << i << " ";  // ok
   //i = 100;              // error
}

( एक डेमो देखें )

अद्यतन : @ मानव-संकलक की टिप्पणी से प्रेरित , मैं सोच रहा था कि दिए गए उत्तरों में प्रदर्शन के मामले में कोई अंतर है। यह पता चला है कि, इस दृष्टिकोण को छोड़कर, अन्य सभी दृष्टिकोणों के लिए आश्चर्यजनक रूप से समान प्रदर्शन (सीमा के लिए [0, 10)) है। std::vectorदृष्टिकोण सबसे खराब है।

( ऑनलाइन क्विक-बेंच देखें )

Question 7

और यहाँ एक C ++ 11 संस्करण है:

for (int const i : {0,1,2,3,4,5,6,7,8,9,10})
{
    std::cout << i << " ";
    // i = 42; // error
}

यहाँ लाइव डेमो है

Question 8

#include <cstdio>
  
#define protect(var) \
  auto &var ## _ref = var; \
  const auto &var = var ## _ref

int main()
{
  for (int i = 0; i < 10; ++i) 
  {
    {
      protect(i);
      // do something with i
      //
      printf("%d\n", i);
      i = 42; // error!! remove this and it compiles.
    }
  }
}

नोट: हमें भाषा में एक आश्चर्यजनक मूर्खता के कारण गुंजाइश को घोंसला बनाने की आवश्यकता है: for(...)शीर्ष लेख में घोषित चर को उसी घोंसले के स्तर पर माना जाता है क्योंकि {...}यौगिक विवरण में घोषित चर । इसका मतलब है कि, उदाहरण के लिए:

for (int i = ...)
{
  int i = 42; // error: i redeclared in same scope
}

क्या? क्या हमने सिर्फ एक घुंघराला ब्रेस नहीं खोला? इसके अलावा, यह असंगत है:

void fun(int i)
{
  int i = 42; // OK
}

Question 9

एक सरल दृष्टिकोण जो अभी तक यहां उल्लेख नहीं किया गया है कि सी ++ के किसी भी संस्करण में काम करता है, एक रेंज के चारों ओर एक कार्यात्मक आवरण बनाने के लिए है, जो कि std::for_eachपुनरावृत्तियों के समान है। उपयोगकर्ता तब कॉलबैक के रूप में एक कार्यात्मक तर्क में पारित करने के लिए जिम्मेदार होता है जिसे प्रत्येक पुनरावृत्ति पर लागू किया जाएगा।

उदाहरण के लिए:

// A struct that holds the start and end value of the range
struct numeric_range
{
    int start;
    int end;

    // A simple function that wraps the 'for loop' and calls the function back
    template <typename Fn>
    void for_each(const Fn& fn) const {
        for (auto i = start; i < end; ++i) {
            const auto& const_i = i;
            fn(const_i);
        }
    }
};

उपयोग कहां होगा:

numeric_range{0, 10}.for_each([](const auto& i){
   std::cout << i << " ";  // ok
   //i = 100;              // error
});

C ++ 11 से अधिक पुरानी कोई भी चीज़ एक नामित-नामित फ़ंक्शन पॉइंटर में for_each(समान std::for_each) से गुज़रती हुई रुकी होगी , लेकिन यह अभी भी काम करती है।

यहाँ एक डेमो है

यद्यपि यह C ++for में लूप के लिए मुहावरेदार नहीं हो सकता है , यह दृष्टिकोण अन्य भाषाओं में काफी आम है। कार्यात्मक रैपर जटिल बयानों में उनकी रचनाशीलता के लिए वास्तव में चिकना हैं और उपयोग के लिए बहुत एर्गोनोमिक हो सकते हैं।

यह कोड लिखने, समझने और बनाए रखने के लिए भी सरल है।

Question 10

template<class T = int, class F>
void while_less(T n, F f, T start = 0){
    for(; start < n; ++start)
        f(start);
}

int main()
{
    int s = 0;
    
    while_less(10, [&](auto i){
        s += i;
    });
    
    assert(s == 45);
}

शायद इसे बुलाओ for_i

कोई ओवरहेड https://godbolt.org/z/e7asGj