सी ++ सरणी पॉइंटर्स [] या ++

Question

कहता है कि मैं युगल की एक सरणी के माध्यम से पुनरावृत्ति करना चाहता हूं और उन्हें जोड़ना चाहता हूं। मेरे पास ऐसा करने के दो तरीके हैं।

एक)

double sum (double * series, int size) { 
    double sum = 0.0; 
    for (int i = 0; i < size; i++) { 
     sum += *series++; 
    } 
    return sum; 
} 

बी)

double sum (double * series, int size) { 
    double sum = 0.0; 
    for (int i = 0; i < size; i++) { 
     sum += series[i]; 
    } 
    return sum; 
} 

जो बेहतर है और क्यों है/जब मैं एक दूसरे के ऊपर का उपयोग करना चाहिए।

Answer 1

यह पठनीयता का सवाल है, इसे प्रदर्शन को प्रभावित नहीं करना चाहिए। मुझे लगता है कि बी सबसे अधिक पठनीय है, और इसलिए बेहतर है।

double sum (double* begin, double* end) { 
    double sum = 0.; 
    for (double* it = begin; it != end; ++it) { 
     sum += *it; 
    } 
    return sum; 
} 

यह मुहावरेदार सी ++ कई मामलों में है और अधिक आसानी से सामान्यीकरण करता:

मैं भी एक तिहाई संस्करण है, जो सीमा के आधार पर है (ध्यान दें begin और end पैरामीटर) का प्रस्ताव कर सकते हैं। यह कहना नहीं है कि यह हमेशा बेहतर है, यह पठनीयता और रखरखाव के बारे में एक प्रश्न में एक और प्रकार है।

Answer 2

न तो दूसरे की तुलना में स्वाभाविक रूप से बेहतर है; आपको जो भी अपना कोड स्पष्ट करने का इरादा रखता है उसे चुनना चाहिए। किसी भी आधुनिक कंपाइलर के साथ, उन्हें समान मशीन कोड के लिए अनुकूलित किया जाना चाहिए।

---

हालांकि, ध्यान दें कि कच्चे सरणियों के लिए कच्चे संकेत के आसपास गुजर सी ++ में बुरा शैली माना जाता है। std::vector जैसे कंटेनर क्लास का उपयोग करने पर विचार करें।

Answer 3

प्रदर्शन के संदर्भ में आधुनिक अनुकूलन संकलन का उपयोग करते समय कोई अंतर नहीं होना चाहिए।

1 9 78 में, पीडीपी -11 पर पहला रास्ता कुछ तेज था, क्योंकि अप्रत्यक्ष ऑटोइनक्रिकमेंट एड्रेसिंग को प्रक्रिया के लिए कम चक्र की आवश्यकता होती थी, और कोई ऑप्टिमाइज़र नहीं था जो इंडेक्स + ऑफ़सेट को ऑटोइनक्रिकमेंट में परिवर्तित करने में सक्षम था।

पीएस series -= size; को सेट करना कोई प्रभाव नहीं है, क्योंकि series मूल्य से पारित किया गया है।

Answer 4

मैं करूंगा और साथ ही शैली बी चुना है, लेकिन उसके बाद आप स्पष्ट छोरों से अधिक मानक एल्गोरिदम को प्राथमिकता देनी चाहिए:

#include <numeric> 

double sum(const double* const series, const int size) { 
    return std::accumulate(series, series + size, 0.0); 
} 

Answer 5

सी ++ 11 रास्ता सरणी पुनरावृति करने के लिए (यदि आपने अभी योग नहीं करना चाहते उन्हें और उस संचित अपनी जरूरत फिट नहीं करता है) है:

double sum (const double * series, int size) { 
    double sum = 0.0; 
    for_each (series, series + size, [&](double v) { 
     sum += v; 
    }); 
    return sum; 
} 

ध्यान दें कि यदि आप एक वेक्टर या एक सूची के लिए इस्तेमाल किया आप बहुत ज्यादा एक ही कोड प्राप्त चाहते हैं:

double sum (const vector<double>& series) { 
    double sum = 0.0; 
    for_each (begin(series), end(series), [&](double v) { 
     sum += v; 
    }); 
    return sum; 
}