# cstddef

***

**1. Determine the Size of a Data Type**

```cpp
#include <cstddef>

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

**2. Allocate Memory for an Array**

```cpp
#include <cstddef>

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

**3. Iterate Over an Array using Pointers**

```cpp
#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**

```cpp
#include <cstddef>
#include <cstring>

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

**5. Compare Arrays using memcmp**

```cpp
#include <cstddef>
#include <cstring>

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

**6. Align Memory for Efficient Access**

```cpp
#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**

```cpp
#include <cstddef>

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

**8. Create a Dynamic Array**

```cpp
#include <cstddef>
#include <vector>

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

**9. Traverse a List using Iterators**

```cpp
#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**

```cpp
#include <cstddef>
#include <set>

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

**11. Resize a Container Dynamically**

```cpp
#include <cstddef>
#include <vector>

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

**12. Check if a Container is Empty**

```cpp
#include <cstddef>
#include <map>

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

**13. Erase an Element from a Container**

```cpp
#include <cstddef>
#include <set>

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

**14. Find an Element in a Sorted Container**

```cpp
#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**

```cpp
#include <cstddef>
#include <set>

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

**16. Create a Multimap**

```cpp
#include <cstddef>
#include <map>

multimap<int, int> my_multimap;
```

**17. Create a Multiset**

```cpp
#include <cstddef>
#include <set>

multiset<int> my_multiset;
```

**18. Create a Queue**

```cpp
#include <cstddef>
#include <queue>

queue<int> my_queue;
```

**19. Create a Deque**

```cpp
#include <cstddef>
#include <deque>

deque<int> my_deque;
```

**20. Create a Stack**

```cpp
#include <cstddef>
#include <stack>

stack<int> my_stack;
```

**21. Create a Heap**

```cpp
#include <cstddef>
#include <heap>

heap<int> my_heap;
```

**22. Create a Binary Search Tree**

```cpp
#include <cstddef>
#include <tree>

tree<int> my_tree;
```

**23. Create a Red-Black Tree**

```cpp
#include <cstddef>
#include <tree>

rb_tree<int> my_rb_tree;
```

**24. Create a Splay Tree**

```cpp
#include <cstddef>
#include <tree>

splay_tree<int> my_splay_tree;
```

**25. Create a AVL Tree**

```cpp
#include <cstddef>
#include <tree>

avl_tree<int> my_avl_tree;
```

**26. Create a Hash Table**

```cpp
#include <cstddef>
#include <unordered_map>

unordered_map<int, int> my_hash_table;
```

**27. Create a Bloom Filter**

```cpp
#include <cstddef>
#include <bloom_filter>

bloom_filter<int> my_bloom_filter;
```

**28. Create a Trie**

```cpp
#include <cstddef>
#include <trie>

trie<int> my_trie;
```

**29. Create a Suffix Tree**

```cpp
#include <cstddef>
#include <suffix_tree>

suffix_tree<int> my_suffix_tree;
```

**30. Create a B-Tree**

```cpp
#include <cstddef>
#include <b_tree>

b_tree<int> my_b_tree;
```

**31. Create an R-Tree**

```cpp
#include <cstddef>
#include <r_tree>

r_tree<int> my_r_tree;
```

**32. Create a Quad Tree**

```cpp
#include <cstddef>
#include <quad_tree>

quad_tree<int> my_quad_tree;
```

**33. Create an Octree**

```cpp
#include <cstddef>
#include <octree>

octree<int> my_octree;
```

**34. Create a K-D Tree**

```cpp
#include <cstddef>
#include <k_d_tree>

k_d_tree<int> my_k_d_tree;
```

**35. Create a Van Emde Boas Tree**

```cpp
#include <cstddef>
#include <van_emde_boas_tree>

van_emde_boas_tree<int> my_van_emde_boas_tree;
```

**36. Create a Fibonacci Heap**

```cpp
#include <cstddef>
#include <fibonacci_heap>

fibonacci_heap<int> my_fibonacci_heap;
```

**37. Create a Pairing Heap**

```cpp
#include <cstddef>
#include <pairing_heap>

pairing_heap<int> my_pairing_heap;
```

**38. Create a Leftist Heap**

```cpp
#include <cstddef>
#include <leftist_heap>

leftist_heap<int> my_leftist_heap;
```

**39. Create a Binary Heap**

```cpp
#include <cstddef>
#include <binary_heap>

binary_heap<int> my_binary_heap;
```

**40. Create a Reverse Binary Heap**

```cpp
#include <cstddef>
#include <reverse_binary_heap>

reverse_binary_heap<int> my_reverse_binary_heap;
```

**41. Create a Selection Tree**

```cpp
#include <cstddef>
#include <selection_tree>

selection_tree<int> my_selection_tree;
```

**42. Create a Randomized Selection Tree**

```cpp
#include <cstddef>
#include <randomized_selection_tree>

randomized_selection_tree<int> my_randomized_selection_tree;
```

**43. Create a Buffer**

```cpp
#include <cstddef>
#include <buffer>

buffer<int> my_buffer;
```

**44. Create an Array Buffer**

```cpp
#include <cstddef>
#include <array_buffer>

array_buffer<int> my_array_buffer;
```

**45. Create a Circular Buffer**

```cpp
#include <cstddef>
#include <circular_buffer>

circular_buffer<int> my_circular_buffer;
```

**46. Create a Ring Buffer**

```cpp
#include <cstddef>
#include <ring_buffer>

ring_buffer<int> my_ring_buffer;
```

**47. Create a Queue Buffer**

```cpp
#include <cstddef>
#include <queue_buffer>

queue_buffer<int> my_queue_buffer;
```

**48. Create a Deque Buffer**

```cpp
#include <cstddef>
#include <deque_buffer>

deque_buffer<int> my_deque_buffer;
```

**49. Create a Stack Buffer**

```cpp
#include <cstddef>
#include <stack_buffer>

stack_buffer<int> my_stack_buffer;
```

**50. Create a Priority Queue Buffer**

```cpp
#include <cstddef>
#include <priority_queue_buffer>

priority_queue_buffer<int> my_priority_queue_buffer;
```