stdlib

---

1. Random Number Generation

#include <random>

std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<int> dist(1, 6);

for (int i = 0; i < 10; i++)
  std::cout << dist(gen) << " ";

2. Vector Manipulation

#include <vector>

std::vector<int> v = {1, 2, 3, 4, 5};
v.push_back(6);
v.pop_back();
v.insert(v.begin() + 2, 7);
v.erase(v.begin() + 3);

3. String Manipulation

#include <string>

std::string s = "Hello World";
s.append("!");
s.replace(6, 5, "Universe");
s.find("World");
s.substr(0, 5); // "Hello"

4. File Reading and Writing

#include <fstream>

std::ifstream ifs("input.txt");
std::ofstream ofs("output.txt");
ofs << ifs.rdbuf();

5. Regex Matching

#include <regex>

std::regex re("^[a-z0-9]+$");
std::string s = "abc123";
std::cout << std::regex_match(s, re) << std::endl;

6. Date and Time Manipulation

#include <ctime>

std::time_t t = std::time(nullptr);
std::tm* tm = std::localtime(&t);

std::cout << tm->tm_year + 1900 << "-"
          << tm->tm_mon + 1 << "-"
          << tm->tm_mday << std::endl;

7. Mathematical Functions

#include <cmath>

std::cout << std::sqrt(4) << std::endl;
std::cout << std::pow(2, 3) << std::endl;
std::cout << std::log10(100) << std::endl;

8. Input and Output

#include <iostream>

std::cout << "Enter a number: ";
int num;
std::cin >> num;

std::cout << "The number you entered is: " << num << std::endl;

9. Containers (Lists)

#include <list>

std::list<int> l = {1, 2, 3, 4, 5};
l.push_back(6);
l.pop_back();
l.insert(l.begin(), 0);

10. Containers (Sets)

#include <set>

std::set<std::string> s = {"apple", "banana", "cherry"};
s.insert("dog");
s.erase("apple");

11. Containers (Maps)

#include <map>

std::map<std::string, int> m = {{"apple", 1}, {"banana", 2}, {"cherry", 3}};
m["dog"] = 4;
m.erase("apple");

12. Algorithms (Sorting)

#include <algorithm>

std::vector<int> v = {1, 5, 2, 4, 3};
std::sort(v.begin(), v.end());

13. Algorithms (Searching)

#include <algorithm>

std::vector<int> v = {1, 5, 2, 4, 3};
std::cout << std::binary_search(v.begin(), v.end(), 3) << std::endl;

14. Algorithms (Counting)

#include <algorithm>

std::vector<int> v = {1, 2, 2, 3, 4, 5, 6, 6, 6};
std::cout << std::count(v.begin(), v.end(), 6) << std::endl;

15. Algorithms (Min and Max)

#include <algorithm>

std::vector<int> v = {1, 5, 2, 4, 3};
std::cout << std::min_element(v.begin(), v.end()) << std::endl;
std::cout << std::max_element(v.begin(), v.end()) << std::endl;

16. Algorithms (Accumulate)

#include <algorithm>

std::vector<int> v = {1, 2, 3, 4, 5};
std::cout << std::accumulate(v.begin(), v.end(), 0) << std::endl;

17. Iterators

#include <iterator>

std::vector<int> v = {1, 2, 3, 4, 5};
std::copy(v.begin(), v.end(),
         std::ostream_iterator<int>(std::cout, " "));

18. Function Objects

#include <functional>

std::vector<int> v = {1, 2, 3, 4, 5};
std::sort(v.begin(), v.end(), std::greater<int>());

19. Lambdas

#include <vector>

std::vector<int> v = {1, 2, 3, 4, 5};
std::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });

20. Exceptions

#include <exception>

try {
  // Do something that may throw an exception
} catch (std::exception& e) {
  // Handle the exception
}

21. Threads

#include <thread>

std::thread t([] {
  // Do something in a separate thread
});
t.join();

22. Mutexes

#include <mutex>

std::mutex m;

void func() {
  std::lock_guard<std::mutex> lock(m);
  // Do something that needs to be synchronized
}

23. Condition Variables

#include <condition_variable>

std::condition_variable cv;
std::mutex m;

void func() {
  std::unique_lock<std::mutex> lock(m);
  cv.wait(lock);
  // Do something that depends on a condition being met
}

24. Filesystem

#include <filesystem>

namespace fs = std::filesystem;

fs::create_directory("my_directory");
fs::remove_all("my_directory");

25. Random Access Iterators

#include <iterator>

std::vector<int> v = {1, 2, 3, 4, 5};
std::random_access_iterator<int> it = v.begin();
it += 2;

26. Reverse Iterators

#include <iterator>

std::vector<int> v = {1, 2, 3, 4, 5};
std::reverse_iterator<std::vector<int>::iterator> it = v.rbegin();

27. Input Iterators

#include <iterator>

std::ifstream ifs("input.txt");
std::istream_iterator<int> it(ifs);

28. Output Iterators

#include <iterator>

std::ofstream ofs("output.txt");
std::ostream_iterator<int> it(ofs, "\n");

29. Function Templates

#include <functional>

template <typename T>
T max(T a, T b) {
  return a > b ? a : b;
}

30. Class Templates

#include <iostream>

template <typename T>
class Stack {
  T data[100];
  int top;
public:
  Stack() : top(-1) {}
  void push(T value) { data[++top] = value; }
  T pop() { return data[top--]; }
  bool empty() { return top == -1; }
};

31. Smart Pointers (unique_ptr)

#include <memory>

std::unique_ptr<int> ptr(new int(5));
std::cout << *ptr << std::endl; // 5

32. Smart Pointers (shared_ptr)

#include <memory>

std::shared_ptr<int> ptr = std::make_shared<int>(5);
std::cout << *ptr << std::endl; // 5

33. Smart Pointers (weak_ptr)

#include <memory>

std::weak_ptr<int> wptr;
{
  std::shared_ptr<int> ptr(new int(5));
  wptr = ptr;
}
std::cout << *wptr.lock() << std::endl; // 5

34. Bit Manipulation

#include <bitset>

std::bitset<8> b1(0b11001011);
std::bitset<8> b2(0b10110100);

std::cout << (b1 & b2) << std::endl; // 0b10000000
std::cout << (b1 | b2) << std::endl; // 0b11111111

35. Containers (Unordered Map)

#include <unordered_map>

std::unordered_map<std::string, int> m = {{"apple", 1}, {"banana", 2}};
m["cherry"] = 3;
std::cout << m["apple"] << std::endl; // 1

36. Containers (Unordered Set)

#include <unordered_set>

std::unordered_set<std::string> s = {"apple", "banana"};
s.insert("cherry");
std::cout << (s.count("apple") > 0) << std::endl; // true

37. Containers (Deque)

#include <deque>

std::deque<int> d = {1, 2, 3, 4, 5};
d.push_front(0);
d.push_back(6);

38. Containers (Stack)

#include <stack>

std::stack<int> s;
s.push(1);
s.push(2);
s.push(3);
std::cout << s.top() << std::endl; // 3

39. Containers (Queue)

#include <queue>

std::queue<int> q;
q.push(1);
q.push(2);
q.push(3);
std::cout << q.front() << std::endl; // 1

40. Algorithms (Permutation)

#include <algorithm>

std::vector<int> v = {1, 2, 3, 4};
std::next_permutation(v.begin(), v.end());

41. Algorithms (Combination)

#include <algorithm>

std::vector<int> v = {1, 2, 3, 4};
std::vector<std::vector<int>> combinations;
std::copy_if(v.begin(), v.end(),
             std::back_inserter(combinations),
             [](int i) { return i % 2 == 1; });

42. Algorithms (Heap)

#include <algorithm>

std::vector<int> v = {1, 2, 3, 4, 5};
std::make_heap(v.begin(), v.end());
std::cout << v.front() << std::endl; // 1

43. Algorithms (Sort)

#include <algorithm>

std::vector<int> v = {1, 2, 3, 4, 5};
std::sort(v.begin(), v.end(), std::greater<int>());

44. Algorithms (Merge)

#include <algorithm>

std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = {4, 5, 6};
std::vector<int> v3;
std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(v3));

45. Algorithms (Set Operations)

#include <algorithm>

std::set<int> s1 = {1, 2, 3};
std::set<int> s2 = {3, 4, 5};
std::set<int> s3;
std::set_union(s1.begin(), s1.end(), s2.begin(), s2.end(), std::inserter(s3, s3.begin()));

46. Algorithms (Numeric Operations)

#include <numeric>

std::vector<int> v = {1, 2, 3, 4, 5};
std::cout << std::accumulate(v.begin(), v.end(), 0) << std::endl; // 15

47. Type Traits

#include <type_traits>

static_assert(std::is_integral<int>::value, "int is not an integral type");

48. Macros

#define MAX(a, b) ((a) > (b) ? (a) : (b))
std::cout << MAX(5, 10) << std::endl; // 10

49. Inline Functions

inline int max(int a, int b) {
  return a > b ? a : b;
}
std::cout << max(5, 10) << std::endl; // 10

50. Error Handling (Assert)

#include <cassert>

int main() {
  int x = 10;
  assert(x == 10); // No error
  x = 15;
  assert(x == 10); // Assertion error
}