C++ STL

#include <map>

map<string, int> scores;

// Insert
scores["Alice"] = 92;
scores.insert({"Bob", 85});
scores.emplace("Carol", 78);

// Access
scores["Alice"]          // 92 (creates if missing!)
scores.at("Alice")      // 92 (throws if missing)

// Check existence
scores.count("Bob")       // 1 or 0
scores.find("Bob") != scores.end()

// Erase
scores.erase("Bob");

// Iterate (sorted by key)
for (auto& [k, v] : scores)
    cout << k << ": " << v << "\n";

#include <unordered_map>

unordered_map<string, int> freq;

// Count word frequency
vector<string> words = {"a","b","a"};
for (auto& w : words)
    freq[w]++;
// freq["a"]=2, freq["b"]=1

// get_or_default pattern
int val = freq.count("x")
           ? freq["x"] : 0;

// C++17 — contains()
if (freq.contains("a"))
    cout << "found\n";

#include <set>

set<int> s = {3,1,4,1,5};
// stores: {1, 3, 4, 5} — sorted, unique

s.insert(2);
s.erase(3);
s.count(4)      // 1 (exists) or 0
s.size()

// Iteration — always sorted
for (int x : s)
    cout << x << " ";  // 1 2 4 5

// Lower/upper bound
auto it = s.lower_bound(3); // first >= 3
auto it = s.upper_bound(3); // first > 3

#include <unordered_set>

unordered_set<string> visited;

visited.insert("home");
visited.insert("work");

// O(1) membership check
if (visited.count("home"))
    cout << "already visited\n";

// Remove duplicates from vector
vector<int> v = {1,2,2,3};
unordered_set<int> unique(v.begin(),
                              v.end());

vector<int> v = {10,20,30,40};

auto it  = v.begin();  // points to 10
auto end = v.end();    // one past last

*it              // 10 — dereference
++it             // advance to 20
it += 2          // jump 2 (random access)
*it              // 40

// Reverse iterator
for (auto it = v.rbegin();
          it != v.rend(); ++it)
    cout << *it;  // 40 30 20 10

// advance / distance
#include <iterator>
advance(it, 2);
distance(v.begin(), it);

vector<int> v = {1,2,3,4,5};

// Insert before position 2
v.insert(v.begin()+2, 99);
// {1,2,99,3,4,5}

// Erase element at index 3
v.erase(v.begin()+3);

// Erase a range [1, 3)
v.erase(v.begin()+1,
         v.begin()+3);

#include <string>

string s  = "Hello";
string s2 = s + " World";  // concat
s.size()               // 5
s.length()             // same
s.empty()              // false
s[0]                   // 'H'
s.at(1)                // 'e'
s.front()              // 'H'
s.back()               // 'o'
s.substr(1, 3)         // "ell"
s.find("ll")           // 2 (index)
s.find("xyz")          // string::npos
s.replace(1,3,"ELL")   // "HELLO"
s.erase(1, 2)          // erase 2 chars at 1

// int / double ↔ string
string ns = to_string(42);
int    n  = stoi("42");
double d  = stod("3.14");
long   l  = stol("100");

// C string ↔ std::string
const char* cs = s.c_str();
string s2(cs);

// String stream — split / parse
#include <sstream>
stringstream ss("10 20 30");
int a, b, c;
ss >> a >> b >> c;
// a=10, b=20, c=30

// [capture](params) -> ret { body }

// Basic lambda
auto add = [](int a, int b) {
    return a + b;
};
add(3, 4)  // 7

// Capture by value [=]
int limit = 5;
auto small = [=](int x) {
    return x < limit;
};

// Capture by reference [&]
int total = 0;
auto acc = [&](int x) {
    total += x;  // modifies outer total
};

// Use with algorithm
vector<int> v={1,2,3,4,5};
for_each(v.begin(), v.end(), acc);
// total = 15

// auto — let compiler infer type
auto x  = 42;          // int
auto d  = 3.14;        // double
auto s  = string("hi");

// Structured bindings (C++17)
map<string,int> m;
for (auto& [key, val] : m)
    cout << key << val;

// pair and tuple
pair<int,string> p = {1,"hi"};
p.first;  p.second;

tuple<int,string,double> t{1,"a",3.0};
get<0>(t);  // 1
auto& [a,b,c] = t;  // unpack