C++ में सदिशों का कुशल पुनरावृत्ति

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

विषयवस्तु सारणी

• C++ में वेक्टर्स को समझना
• पारंपरिक for लूप के साथ पुनरावृत्ति
• रेंज-आधारित for लूप के साथ पुनरावृत्ति
• पुनरावृत्तियों के साथ पुनरावृत्ति
• सही पुनरावृत्ति विधि चुनना

C++ में वेक्टर्स को समझना

C++ स्टैंडर्ड टेम्पलेट लाइब्रेरी (STL) का हिस्सा वेक्टर्स, <vector> हेडर का उपयोग करके घोषित किए जाते हैं। वे पारंपरिक C-शैली सरणियों पर महत्वपूर्ण लाभ प्रदान करते हैं:

• गतिशील आकार: वेक्टर्स आवश्यकतानुसार स्वचालित रूप से आकार बदलते हैं, जिससे मेमोरी प्रबंधन सरल हो जाता है।
• आसान तत्व पहुँच: तत्वों को [] ऑपरेटर का उपयोग करके एक्सेस किया जाता है, जो सरणियों के समान है।
• STL एकीकरण: वेक्टर्स अन्य STL घटकों के साथ सहज रूप से एकीकृत होते हैं।

यहाँ एक वेक्टर को घोषित और इनिशियलाइज़ करने का तरीका बताया गया है:

#include <iostream>
#include <vector>

int main() {
  std::vector<int> myVector = {1, 2, 3, 4, 5};
  return 0;
}

पारंपरिक for लूप के साथ पुनरावृत्ति

एक पारंपरिक for लूप पुनरावृत्ति पर स्पष्ट नियंत्रण प्रदान करता है:

#include <iostream>
#include <vector>

int main() {
  std::vector<int> myVector = {1, 2, 3, 4, 5};

  for (size_t i = 0; i < myVector.size(); ++i) {
    std::cout << myVector[i] << " ";
  }
  std::cout << std::endl; // आउटपुट: 1 2 3 4 5
  return 0;
}

लूप काउंटर के लिए size_t का उपयोग संगतता सुनिश्चित करता है और संभावित चेतावनियों से बचाता है।

रेंज-आधारित for लूप के साथ पुनरावृत्ति

C++11 में पेश किया गया, रेंज-आधारित for लूप पुनरावृत्ति को सरल करता है:

#include <iostream>
#include <vector>

int main() {
  std::vector<int> myVector = {1, 2, 3, 4, 5};

  for (auto element : myVector) {
    std::cout << element << " ";
  }
  std::cout << std::endl; // आउटपुट: 1 2 3 4 5
  return 0;
}

auto स्वचालित रूप से तत्व प्रकार को निर्धारित करता है, जिससे कोड संक्षिप्त और पठनीय बन जाता है।

पुनरावृत्तियों के साथ पुनरावृत्ति

पुनरावृत्तियाँ कंटेनरों को पार करने का एक शक्तिशाली और लचीला तरीका प्रदान करती हैं। वे आगे, पीछे और अन्य ट्रैवर्सल विधियों का समर्थन करते हैं। जबकि साधारण पुनरावृत्ति के लिए कम संक्षिप्त, वे जटिल संक्रियाओं के लिए आवश्यक हैं।

#include <iostream>
#include <vector>

int main() {
  std::vector<int> myVector = {1, 2, 3, 4, 5};

  for (std::vector<int>::iterator it = myVector.begin(); it != myVector.end(); ++it) {
    std::cout << *it << " ";
  }
  std::cout << std::endl; // आउटपुट: 1 2 3 4 5
  return 0;
}

myVector.begin() और myVector.end() क्रमशः वेक्टर की शुरुआत और अंत के बाद इंगित करने वाले पुनरावृत्तियों को वापस करते हैं। डिरेफरेंस ऑपरेटर (*) पुनरावृत्ति के मान तक पहुँचता है।

सही पुनरावृत्ति विधि चुनना

सर्वोत्तम पुनरावृत्ति विधि आपकी आवश्यकताओं पर निर्भर करती है। साधारण पुनरावृत्ति के लिए, रेंज-आधारित for लूप को अक्सर इसकी पठनीयता और दक्षता के लिए प्राथमिकता दी जाती है। पारंपरिक for लूप अधिक नियंत्रण प्रदान करता है, जबकि उन्नत परिदृश्यों के लिए पुनरावृत्तियाँ सबसे बड़ी लचीलापन प्रदान करती हैं।