लूप

Question

की स्थिति को सशर्त रूप से नियंत्रित करने का सबसे अच्छा तरीका क्या है मेरे पास मेरे कोड में एक ब्लॉक है जिसमें लूप को किसी शर्त के आधार पर आगे या पीछे चलना चाहिए।

if (forwards) { 
    for (unsigned x = 0; x < something.size(); x++) { 
     // Lots of code 
    } 

} else { 
    for (unsigned x = something.size()-1 ; x >= 0 ; x--) { 
     // Lots of code 
    } 
} 

क्या इसे स्थापित करने का कोई अच्छा तरीका है, इसलिए मैं दो बार लूप के भीतर सभी कोड दोहराता नहीं हूं?

प्रश्न में 'कुछ' एक std :: vector <> है, तो हो सकता है कि यह एक पुनरावर्तक के साथ संभव हो?

Answer 1

अलग आप पाश अंदर का उपयोग मूल्य से पाश मूल्य (मैं सी ++ 11 का उपयोग नहीं कर रहा हूँ):

for (unsigned x2 = 0; x2 < something.size(); x2++) { 
    const int x = forward ? x2 : (something.size()-1) - x2; 
    // Lots of code using x 
} 

Answer 2

शायद सबसे आसान तरीका है तर्क x के साथ एक समारोह के लिए Lots of code कन्वर्ट करने के लिए है

void do_lots_of_stuff(unsigned x) { 
    // Lots of code 
} 

//////// 

if (forwards) { 
    for (unsigned x = 0; x < something.size(); x++) { 
    do_lots_of_stuff(x); 
    } 
} else { 
    for (unsigned x = something.size()-1 ; x >= 0 ; x--) { 
    do_lots_of_stuff(x); 
    } 
} 

Answer 3

template<typename Cont, typename Func> 
Func directional_for_each(Cont c, bool forwards, Func f) { 
    return forwards ? for_each(begin(c), end(c), f) : for_each(rbegin(c), rend(c), f); 
} 

इस तरह उपयोग किया:: और उस समारोह के लिए एक कॉल के साथ दोनों पाश निकायों की जगह

vector<int> v; 
// put stuff in v... 
bool forwards = false; 
directional_for_each(v, forwards, [](decltype(v[0]) x) { 
    // Lots of code using x 
}); 

जैसा कि आप सी ++ 11 का उपयोग नहीं कर रहे हैं, जिसमें 'एक्स का उपयोग कर बहुत सारे कोड' वाले लैम्ब्डा को कहीं और परिभाषित फ़ंक्शन के साथ प्रतिस्थापित करना होगा।

Answer 4

या आप कुछ इस तरह कर सकते हैं:

for (unsigned x = (forward ? 0: something.size()); x != (forward ? something.size() :0); forward? x++: x--) { 
    // Lots of code 
} 

संकलक सबसे अधिक संभावना यह अनुकूलन और forward का मूल्यांकन केवल एक बार के बाद से यह मूल्य for पाश मुझे लगता है में परिवर्तन नहीं करता है जाएगा।

Answer 5

मैं इस सवाल पर आने के लिए ऐसा हुआ और सोचा कि मैं सशर्त रूप से प्रत्येक लूप की जांच किए बिना समाधान प्रदान कर सकता हूं चाहे आगे या पीछे नहीं जाना है या नहीं।

// Could do 0xFFFFFFFFU if unsigned is 32bits. 
const unsigned MAX_UINT = 0U - 1U; 

// Will need this later. 
const bool backwards = !forwards; 

// temp is either going to be one or zero. 
const unsigned temp = unsigned(forwards); 

// By adding it to all ones, if temp is ones the mask is all zeros 
// else if temp is zero we get all ones. 
const unsigned mask = temp + MAX_UINT; 

// Bit shift temp over such that it will push all of the ones after 
// the first bit to all zeros if temp is one. This means we will 
// either have a one or a negative one if temp is zero. 
const int delta = int((temp << 1) + MAX_UINT); 

const int size = something.size(); 

// The mask will be zero if forwards is true therein i will start out 
// at zero else the mask will be all ones therein return (size - 1). 
for(int i = int((size - 1) & mask); 
// This may be a more complicated check, but there is only one conditional branch. 
    (forwards && (i < size)) || (backwards (0 <= i)); 
    i += delta) 
{ 
    // Lots of code 
}