2 लूप चर के साथ सी ++ में फॉर-लूप लिखना इतना कठिन क्यों है?

Question

संभव डुप्लिकेट:

int myIndex; 
for (myIndex=0;myIndex<10;++myIndex) ... 

एक C++ डेवलपर इस लिखते थे पाश के बाहर लीक से पाश चर को रोकने के लिए:
In C++ why can’t I write a for() loop like this: for(int i = 1, double i2 = 0; …

एसी डेवलपर इस बारे में होगा:

for (int myIndex=0;myIndex<10;++myIndex) ... 

हालांकि, यदि आपके पास 2 लूप चर हैं, तो आप इसे और नहीं कर सकते हैं। निम्नलिखित संकलित करता है नहीं:

for (int myIndex=0,MyElement *ptr=Pool->First;ptr;++myIndex,ptr=ptr->next) ... 

अल्पविराम ऑपरेटर दो चर इस तरह से परिभाषित किया जा करने की अनुमति नहीं है, तो हम इसे इस तरह लिखने के लिए है:

int myIndex; 
MyElement *ptr; 
for (myIndex=0,ptr=Pool->First;ptr;++myIndex,ptr=ptr->next) ... 

कौन सा होने का लाभ धरा वास्तविक पाश-स्थानीय चर।

एक समाधान इस तरह, ब्रेसिज़ के बीच पूरे निर्माण डाल करने के लिए हो सकता है:

{ 
int myIndex; 
MyElement *ptr; 
for (myIndex=0,ptr=Pool->First;ptr;++myIndex,ptr=ptr->next) ... 
} 

लेकिन यह शायद ही और अधिक सुरुचिपूर्ण है।

क्या सी ++ (या सी ++ 0x) में ऐसा करने का कोई बेहतर तरीका नहीं है?

Answer 1

आपको सिर्फ यह समझना है कि पहला कथन एक घोषणा है (और वह अल्पविराम अल्पविराम ऑपरेटर नहीं है)।

for (int i, double d; ...) 

से यह है:

int i, double d; 

क्योंकि for (init cond; expr) statement करने के लिए विस्तारित हो जाता है: यह किसी भी कठिन करने के लिए नहीं है बनाने के लिए किया जाता है

{ 
    init 
    while (cond) 
    { 
     statement 
     expr; 
    } 
} 

एक चाल है कि init बयान एक struct परिभाषा और उदाहरण, जैसे:

for (struct { int myIndex; MyElement* ptr;} data = {0, Pool->First}; 
    data.ptr; 
    ++data.myIndex, data.ptr = data.ptr->next) 
    { 
     // blah... 
    } 

,210

कौन सा रूप में एक ही हो जाता है:

{ 
    struct 
    { 
     int myIndex; 
     MyElement* ptr; 
    } data = {0, Pool->First}; 

    while (data.ptr) 
    { 
     { 
      // blah... 
     } 
     ++data.myIndex, data.ptr = data.ptr->next; 
    } 
} 

लेकिन मुझे लगता है कि बहुत बदसूरत पाते हैं। प्रैक्टिस में, मैं बस इसे आपके जैसा विभाजित कर दूंगा। यदि दायरा वास्तव में एक समस्या है, जो शायद यह नहीं है, तो वहां के अतिरिक्त ब्रेसिज़ फेंक दें।

मुझे नहीं लगता कि बॉयलरप्लेट कोड के बिना यहां सुधार करने के लिए बहुत कुछ है।

Answer 2

कम से कम सी ++ हमें अगर खंड है, जो जो कभी कभी एक चर है कि केवल केवल दिख रहा है जब कुछ हालत सच है की घोषणा करने के लिए किया जाता है में चर घोषित करने के लिए अनुमति देता है:

if (MyElement *ptr=Pool->First) // block is only entered when ptr!=0 
{ 
for (int myIndex=0;ptr;++myIndex,ptr=ptr->next) 
{ 
} 
} 
// ptr is out of scope now. 

यह एक हो सकता है पठनीयता बनाए रखने के दौरान, पीआरटी और सूचकांक के दायरे को सीमित करने के लिए विधि।

Answer 3

अगर मैं वास्तव में पाश के लिए गुंजाइश मैं का प्रयोग करेंगे सीमित करने के लिए चाहता था:

#include <utility> 
for (auto i = std::make_pair(0,Pool->First); 
    i.second; 
    ++i.first, i.second=i.second->next)