cstddef

---

1. Determine the Size of a Data Type

#include <cstddef>

size_t size_of_int = sizeof(int); // 4 bytes on most systems

2. Allocate Memory for an Array

#include <cstddef>

int* arr = new int[size_t(10)];

3. Iterate Over an Array using Pointers

#include <cstddef>

int arr[] = {1, 2, 3};
int* ptr = arr;
size_t size_of_arr = sizeof(arr) / sizeof(*arr);
for (size_t i = 0; i < size_of_arr; i++) {
  cout << *ptr << endl;
  ptr++;
}

4. Copy Memory using memcpy

#include <cstddef>
#include <cstring>

int dest_arr[10];
memcpy(dest_arr, src_arr, sizeof(src_arr));

5. Compare Arrays using memcmp

#include <cstddef>
#include <cstring>

bool arrays_equal = !memcmp(arr1, arr2, sizeof(arr1));

6. Align Memory for Efficient Access

#include <cstddef>
#include <cstdlib>

// Allocate aligned memory
void* aligned_mem = aligned_alloc(16, size_t(1024));

// Free aligned memory
free(aligned_mem);

7. Determine the Size of a Function Pointer

#include <cstddef>

size_t size_of_func_ptr = sizeof(int (*)(int));

8. Create a Dynamic Array

#include <cstddef>
#include <vector>

vector<int> dynamic_arr(size_t(10));

9. Traverse a List using Iterators

#include <cstddef>
#include <list>

list<int> my_list;
for (list<int>::iterator it = my_list.begin(); it != my_list.end(); it++) {
  cout << *it << endl;
}

10. Count the Elements in a Container

#include <cstddef>
#include <set>

set<int> my_set;
size_t num_elements = my_set.size();

11. Resize a Container Dynamically

#include <cstddef>
#include <vector>

vector<int> my_vec;
my_vec.resize(size_t(10));

12. Check if a Container is Empty

#include <cstddef>
#include <map>

map<int, int> my_map;
bool is_empty = my_map.empty();

13. Erase an Element from a Container

#include <cstddef>
#include <set>

set<int> my_set;
my_set.erase(size_t(5));

14. Find an Element in a Sorted Container

#include <cstddef>
#include <map>

map<int, int> my_map;
auto it = my_map.find(size_t(5));

15. Insert an Element into a Sorted Container

#include <cstddef>
#include <set>

set<int> my_set;
my_set.insert(size_t(5));

16. Create a Multimap

#include <cstddef>
#include <map>

multimap<int, int> my_multimap;

17. Create a Multiset

#include <cstddef>
#include <set>

multiset<int> my_multiset;

18. Create a Queue

#include <cstddef>
#include <queue>

queue<int> my_queue;

19. Create a Deque

#include <cstddef>
#include <deque>

deque<int> my_deque;

20. Create a Stack

#include <cstddef>
#include <stack>

stack<int> my_stack;

21. Create a Heap

#include <cstddef>
#include <heap>

heap<int> my_heap;

22. Create a Binary Search Tree

#include <cstddef>
#include <tree>

tree<int> my_tree;

23. Create a Red-Black Tree

#include <cstddef>
#include <tree>

rb_tree<int> my_rb_tree;

24. Create a Splay Tree

#include <cstddef>
#include <tree>

splay_tree<int> my_splay_tree;

25. Create a AVL Tree

#include <cstddef>
#include <tree>

avl_tree<int> my_avl_tree;

26. Create a Hash Table

#include <cstddef>
#include <unordered_map>

unordered_map<int, int> my_hash_table;

27. Create a Bloom Filter

#include <cstddef>
#include <bloom_filter>

bloom_filter<int> my_bloom_filter;

28. Create a Trie

#include <cstddef>
#include <trie>

trie<int> my_trie;

29. Create a Suffix Tree

#include <cstddef>
#include <suffix_tree>

suffix_tree<int> my_suffix_tree;

30. Create a B-Tree

#include <cstddef>
#include <b_tree>

b_tree<int> my_b_tree;

31. Create an R-Tree

#include <cstddef>
#include <r_tree>

r_tree<int> my_r_tree;

32. Create a Quad Tree

#include <cstddef>
#include <quad_tree>

quad_tree<int> my_quad_tree;

33. Create an Octree

#include <cstddef>
#include <octree>

octree<int> my_octree;

34. Create a K-D Tree

#include <cstddef>
#include <k_d_tree>

k_d_tree<int> my_k_d_tree;

35. Create a Van Emde Boas Tree

#include <cstddef>
#include <van_emde_boas_tree>

van_emde_boas_tree<int> my_van_emde_boas_tree;

36. Create a Fibonacci Heap

#include <cstddef>
#include <fibonacci_heap>

fibonacci_heap<int> my_fibonacci_heap;

37. Create a Pairing Heap

#include <cstddef>
#include <pairing_heap>

pairing_heap<int> my_pairing_heap;

38. Create a Leftist Heap

#include <cstddef>
#include <leftist_heap>

leftist_heap<int> my_leftist_heap;

39. Create a Binary Heap

#include <cstddef>
#include <binary_heap>

binary_heap<int> my_binary_heap;

40. Create a Reverse Binary Heap

#include <cstddef>
#include <reverse_binary_heap>

reverse_binary_heap<int> my_reverse_binary_heap;

41. Create a Selection Tree

#include <cstddef>
#include <selection_tree>

selection_tree<int> my_selection_tree;

42. Create a Randomized Selection Tree

#include <cstddef>
#include <randomized_selection_tree>

randomized_selection_tree<int> my_randomized_selection_tree;

43. Create a Buffer

#include <cstddef>
#include <buffer>

buffer<int> my_buffer;

44. Create an Array Buffer

#include <cstddef>
#include <array_buffer>

array_buffer<int> my_array_buffer;

45. Create a Circular Buffer

#include <cstddef>
#include <circular_buffer>

circular_buffer<int> my_circular_buffer;

46. Create a Ring Buffer

#include <cstddef>
#include <ring_buffer>

ring_buffer<int> my_ring_buffer;

47. Create a Queue Buffer

#include <cstddef>
#include <queue_buffer>

queue_buffer<int> my_queue_buffer;

48. Create a Deque Buffer

#include <cstddef>
#include <deque_buffer>

deque_buffer<int> my_deque_buffer;

49. Create a Stack Buffer

#include <cstddef>
#include <stack_buffer>

stack_buffer<int> my_stack_buffer;

50. Create a Priority Queue Buffer

#include <cstddef>
#include <priority_queue_buffer>

priority_queue_buffer<int> my_priority_queue_buffer;