Standard Template Library (STL)

STL क्या है?

मान लीजिए आपको कितने भी students के marks रखने हैं, उन्हें sort करना है और सबसे ज़्यादा marks खोजने हैं। C में आप अपना dynamic array, अपना sort और अपना search लिखेंगे — और तीनों को debug करेंगे। Standard Template Library (STL) यह सब तैयार, tested और तेज़ रूप में देती है:

std::vector<int> marks = {78, 91, 66, 84};
std::sort(marks.begin(), marks.end());

STL data structures और algorithms के लिए templates — किसी भी data type के साथ चलने वाला generic code — का संग्रह है। इसे Alexander Stepanov ने design किया और 1998 में यह standard C++ का हिस्सा बनी। यह lesson पहली झलक है; गहराई के लिए देखें C++ STL guide।

चार components

मुख्य design विचार: algorithms containers के बारे में नहीं जानते। वे iterators की जोड़ी (range) पर काम करते हैं, इसलिए एक ही sort vector, deque या साधारण array पर चलता है।

पहला उदाहरण: रखना, sort करना, खोजना

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> marks = {78, 91, 66, 84, 91, 55};

    marks.push_back(73);                                   // container बढ़ता है

    std::sort(marks.begin(), marks.end());                 // algorithm
    std::cout << "Sorted: ";
    for (int m : marks) std::cout << m << " ";
    std::cout << "\n";

    auto best = std::max_element(marks.begin(), marks.end());   // iterator
    std::cout << "Highest: " << *best << "\n";

    int toppers = std::count(marks.begin(), marks.end(), 91);
    std::cout << "Students with 91: " << toppers << "\n";

    auto it = std::find(marks.begin(), marks.end(), 66);
    if (it != marks.end())
        std::cout << "66 found at position " << (it - marks.begin()) << "\n";
    return 0;
}

न manual memory management, न हाथ से लिखा sorting loop — और हर line बताती है कि वह क्या करती है।

Containers के प्रकार

Sequence containers — जिस क्रम में डालें उसी क्रम में

• [vector](/tutorial/cpp/vector/?lang=hi) — dynamic array; index से तेज़ access, अंत में तेज़ जोड़ना/हटाना।
• [deque](/tutorial/cpp/list-deque/?lang=hi) — double-ended queue; दोनों सिरों पर तेज़ जोड़ना/हटाना।
• [list](/tutorial/cpp/list-deque/?lang=hi) — doubly linked list; iterator हो तो कहीं भी तेज़ insert/erase।
• array — STL features वाला fixed-size array।
• forward_list — singly linked list।

Associative containers — key के हिसाब से sorted

• [set / multiset](/tutorial/cpp/set-map/?lang=hi) — sorted values (unique / duplicates allowed)।
• [map / multimap](/tutorial/cpp/set-map/?lang=hi) — sorted key → value जोड़े।

Unordered containers — hash tables

• unordered_set, unordered_map — औसतन O(1) lookup, कोई क्रम नहीं।

Container adapters — सीमित interface

• [stack](/tutorial/cpp/stack-queue/?lang=hi) (LIFO), [queue](/tutorial/cpp/stack-queue/?lang=hi) (FIFO), [priority_queue](/tutorial/cpp/stack-queue/?lang=hi) (सबसे बड़ा पहले)।

कौन-सा container लें?

शक हो तो vector से शुरू करें।

दूसरा उदाहरण: map

#include <iostream>
#include <map>
#include <string>

int main() {
    std::map<std::string, int> marks;
    marks["Priya"] = 91;
    marks["Aman"]  = 78;
    marks["Ravi"]  = 66;

    for (const auto& [name, m] : marks)          // C++17 structured binding
        std::cout << name << " -> " << m << "\n";
    return 0;
}

map नामों को अपने-आप alphabetical क्रम में रखता है।

STL क्यों इस्तेमाल करें?

• सही: लाखों programmers इस्तेमाल करते हैं और compiler बनाने वाले इसे test करते हैं।
• तेज़: algorithms की complexity तय है, जैसे sort O(n log n) है।
• Generic: वही vector int, std::string या आपकी Student class के लिए चलता है।
• कम code: कम loops और manual new/delete नहीं।
• ज़रूरी ज्ञान: लगभग हर C++ interview, competitive programming और असली project में इस्तेमाल।

आम गलतियाँ

• Header भूलना: <vector>, <map>, <algorithm> अलग-अलग include करने होते हैं।
• end() को dereference करना — यह आख़िरी element के *बाद* की ओर इशारा करता है, उस पर नहीं।
• map पर map.find(key) की जगह उसकी range पर find चलाना (बहुत धीमा)।
• Iterators पकड़े रहते हुए vector बदलना (जैसे push_back) — वे invalid हो सकते हैं।
• Key है या नहीं, यह check करने के लिए map पर operator[] लगाना; यह key insert कर देता है। find या count लें।

सारांश

• STL तैयार containers, iterators, algorithms और function objects देती है।
• Algorithms iterator ranges पर काम करते हैं, इसलिए container से स्वतंत्र हैं।
• Sequence, associative, unordered और adapter containers अलग-अलग कामों के लिए हैं।
• vector से शुरू करें; key से lookup के लिए map/unordered_map।
• सही header include करें और end() को कभी dereference न करें।

अगला: vector → list और deque → stack और queue → set और map → iterators → algorithms।