stddef

---

1. Null Pointer

void* ptr = nullptr;

Explanation: Sets ptr to a null pointer, indicating it does not point to any valid memory location.

2. Size of Data Type

size_t size = sizeof(int);

Explanation: Gets the size of the int data type in bytes.

3. Alignment Requirements

ptrdiff_t align = alignof(double);

Explanation: Gets the alignment requirements for the double data type, which indicates the minimum byte boundary on which it can be stored.

4. Pointer Arithmetic

int* ptr = new int[10];
ptr += 5;
*ptr = 10;  // Assigns 10 to the 6th element

Explanation: Pointer arithmetic allows you to increment or decrement a pointer to access different elements in an array.

5. Pointer to Function

int sum(int a, int b) { return a + b; }
int (*ptr_to_sum)(int, int) = ∑
int result = ptr_to_sum(3, 5);  // Calls the `sum` function through the pointer

Explanation: A pointer to a function points to the memory location where the function code is stored.

6. Pointer to Member Function

class A {
public:
    int add(int a, int b) { return a + b; }
};

typedef int (A::*ptr_to_member)(int, int);

void func(A* obj, ptr_to_member add) {
    obj->add(3, 5);  // Calls the `add` member function through the pointer
}

Explanation: A pointer to a member function points to a specific member function of a class.

7. Type Trait: is_same

static_assert(std::is_same<int, int>::value);

Explanation: Checks if two types are the same. In this example, int and int are the same type.

8. Type Trait: is_integral

static_assert(std::is_integral<int>::value);

Explanation: Checks if a type is an integral type, such as int, long, or short.

9. Type Trait: is_floating_point

static_assert(std::is_floating_point<float>::value);

Explanation: Checks if a type is a floating-point type, such as float or double.

10. Type Trait: is_array

static_assert(std::is_array<int[]>::value);

Explanation: Checks if a type is an array type.

11. Type Trait: is_pointer

static_assert(std::is_pointer<int*>::value);

Explanation: Checks if a type is a pointer type.

12. Type Trait: is_reference

static_assert(std::is_reference<int&>::value);

Explanation: Checks if a type is a reference type.

13. Type Trait: remove_reference

static_assert(std::is_same<std::remove_reference<int&>::type, int>::value);

Explanation: Removes the reference from a type. In this example, it gets the type int from the reference type int&.

14. Type Trait: remove_pointer

static_assert(std::is_same<std::remove_pointer<int*>::type, int>::value);

Explanation: Removes the pointer from a type. In this example, it gets the type int from the pointer type int*.

15. Type Trait: remove_const

static_assert(std::is_same<std::remove_const<const int>::type, int>::value);

Explanation: Removes the const qualifier from a type. In this example, it gets the type int from the constant type const int.

16. Type Trait: remove_volatile

static_assert(std::is_same<std::remove_volatile<volatile int>::type, int>::value);

Explanation: Removes the volatile qualifier from a type. In this example, it gets the type int from the volatile type volatile int.

17. Type Trait: decay

static_assert(std::is_same<std::decay<int[10]>::type, int*>::value);

Explanation: Gets the decayed type of a type. In this example, it gets the pointer type int* from the array type int[10].

18. Zero Initialization

int arr[10] = {};

Explanation: Initializes all elements of an array to zero.

19. Constant Initialization

const int x = 10;

Explanation: Initializes a variable with a constant value.

20. Template Metaprogramming

template<int> struct pow : std::integral_constant<int, 2> { };
template<int n> struct pow<n + 1> : std::integral_constant<int, 2 * pow<n>::value> { };

template<int n> static const int value = pow<n>::value;

Explanation: Computes the value of 2n using template metaprogramming.

21. Fixed-size Buffer

std::array<int, 10> arr;

Explanation: Creates a fixed-size array with a specified number of elements.

22. Dynamic Array

std::vector<int> vec;
vec.push_back(10);

Explanation: Creates a dynamic array that can grow and shrink as needed.

23. Linked List

struct Node {
    int data;
    Node* next;
};

Explanation: Implements a linked list data structure.

24. Binary Tree

struct Node {
    int data;
    Node* left;
    Node* right;
};

Explanation: Implements a binary tree data structure.

25. Hash Table

std::unordered_map<int, std::string> map;
map.insert({1, "One"});

Explanation: Implements a hash table data structure for storing key-value pairs.

26. Bit Manipulation

int x = 10;
int bit_set = x | (1 << 2);  // Sets the 3rd bit
int bit_cleared = x & ~(1 << 2);  // Clears the 3rd bit

Explanation: Performs bitwise operations on integers.

27. Thread-safe Data Structure

std::atomic<int> x;
x++;  // Increments the value of x atomically

Explanation: Creates a thread-safe data structure using the std::atomic class.

28. Multi-Threading

std::thread t1([]() { ... });

Explanation: Creates a new thread that executes a specified function.

29. Deadlock Prevention

std::mutex m1;
std::lock_guard<std::mutex> lock(m1);

Explanation: Prevents deadlocks by using a lock and a lock guard.

30. Memory Management

auto* ptr = new int;
delete ptr;

Explanation: Manually manages memory allocation and deallocation.

31. File Handling

std::ifstream file("myfile.txt");
std::ofstream output("myfile.out");

Explanation: Opens files for reading and writing.

32. Input/Output Streams

std::cin >> input;
std::cout << output;

Explanation: Reads input from and writes output to the standard input/output streams.

33. Regular Expressions

std::regex r("pattern");
std::smatch matches;
std::regex_search("input", matches, r);

Explanation: Matches input strings against a regular expression.

34. String Manipulation

std::string str = "Hello";
str.replace(0, 1, "J");  // Replaces "H" with "J"

Explanation: Manipulates strings using the std::string class.

35. Date and Time

time_t now = std::time(nullptr);

Explanation: Gets the current time as a timestamp.

36. Localization

std::setlocale(LC_ALL, "fr_FR");

Explanation: Sets the locale for localized formatting and parsing.

37. Math Functions

double pi = std::acos(-1);

Explanation: Provides access to mathematical functions like trigonometric functions and constants.

38. Random Number Generation

std::uniform_int_distribution<int> dist(1, 10);
auto random = dist(generator);

Explanation: Generates pseudo-random numbers using the standard random number generator.

39. Sorting

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

Explanation: Sorts a container using the standard sort algorithm.

40. Searching

std::vector<int> vec = {1, 3, 5, 2, 4};
auto it = std::find(vec.begin(), vec.end(), 3);

Explanation: Searches for an element in a container using a linear search.

41. Algorithm Execution

std::for_each(vec.begin(), vec.end(), [](int& x) { x *= 2; });

Explanation: Executes a function for each element in a container using the standard for_each algorithm.

42. Iterators

std::vector<int> vec = {1, 3, 5, 2, 4};
for (auto it = vec.begin(); it != vec.end(); ++it) {
    *it *= 2;
}

Explanation: Iterates over a container using iterators.

43. Function Objects

struct Add {
    int operator()(int a, int b) { return a + b; }
};

Explanation: Creates a function object that can be treated as a function.

44. Lambda Expressions

auto add = [](int a, int b) { return a + b; };

Explanation: Creates a lambda expression that represents a function.

45. Exception Handling

try {
    throw std::runtime_error("Error");
} catch (const std::exception& e) {
    std::cout << e.what();
}

Explanation: Catches and handles runtime errors.

46. Assertion

assert(x > 0);

Explanation: Checks a condition and terminates the program if the condition is false.

47. Preprocessor Macros

#define MAX_SIZE 10

Explanation: Defines a preprocessor macro that can be used in code.

48. Conditional Compilation

#ifdef DEBUG
    std::cout << "Debug mode";
#endif

Explanation: Selectively compiles code based on preprocessor conditions.

49. Inline Assembly

asm("mov %%eax, %%ebx");

Explanation: Inserts inline assembly code into the C++ code.

50. Platform-Specific Code

#ifdef _WIN32
    // Windows-specific code
#else
    // Platform-independent code
#endif

Explanation: Writes platform-specific code using preprocessor conditionals.