# cstdint

***

**1. Integer Constant Ranges**

```c++
#include <cstdint>

int main() {
  std::int64_t value = 123456789012345;  // 64-bit integer with range [-9223372036854775808, 9223372036854775807]
  return 0;
}
```

**2. Fixed-Size Integers**

```c++
#include <cstdint>

int main() {
  std::uint8_t small_value = 255;  // 8-bit unsigned integer with range [0, 255]
  std::int32_t medium_value = -12345;  // 32-bit signed integer with range [-2147483648, 2147483647]
  return 0;
}
```

**3. Pointer Size**

```c++
#include <cstdint>

int main() {
  void* pointer = nullptr;
  std::ptrdiff_t pointer_size = std::ptrdiff_t(pointer);  // Size of a pointer in bytes
  return 0;
}
```

**4. Boolean Type**

```c++
#include <cstdint>

int main() {
  std::int64_t boolean_value = true;  // 1 for true, 0 for false
  return 0;
}
```

**5. Maximum and Minimum Values**

```c++
#include <cstdint>

int main() {
  std::int32_t max_value = std::numeric_limits<std::int32_t>::max();  // Maximum value of an int32_t
  std::uint64_t min_value = std::numeric_limits<std::uint64_t>::min();  // Minimum value of a uint64_t
  return 0;
}
```

**6. Constants Macros**

```c++
#include <cstdint>

int main() {
  std::int32_t value = INT16_MAX;  // Maximum value of an int16_t
  std::uint64_t value2 = UINT32_MAX;  // Maximum value of a uint32_t
  return 0;
}
```

**7. Platform-Independent Sizes**

```c++
#include <cstdint>

int main() {
  std::size_t array_size = 10;  // Size of an array in elements
  return 0;
}
```

**8. Enumerated Types**

```c++
#include <cstdint>

enum class Color : std::uint8_t {
  Red = 1,
  Blue = 2,
  Green = 3
};

int main() {
  Color color = Color::Red;
  return 0;
}
```

**9. Bit Fields**

```c++
#include <cstdint>

struct Flags {
  std::uint8_t flag1 : 1;
  std::uint8_t flag2 : 1;
  std::uint8_t flag3 : 1;
};

int main() {
  Flags flags;
  flags.flag1 = true;
  return 0;
}
```

**10. Byte Swapping**

```c++
#include <cstdint>

int main() {
  std::uint16_t value = 0x1234;
  std::uint16_t swapped_value = __bswap_16(value);  // Swap bytes in a 16-bit value
  return 0;
}
```

**11. Fixed-Point Arithmetic**

```c++
#include <cstdint>

int main() {
  std::int64_t a = 12345;
  std::int64_t b = 67890;
  std::int64_t c = a / b;  // Fixed-point division without rounding
  return 0;
}
```

**12. Pointer Arithmetic**

```c++
#include <cstdint>

int main() {
  int* array = new int[10];
  int* end = array + 10;  // Advance pointer by 10 elements
  return 0;
}
```

**13. Address Calculations**

```c++
#include <cstdint>

int main() {
  char* buffer = new char[100];
  char* offset = buffer + 50;  // Calculate address of element 50
  return 0;
}
```

**14. Bit Manipulation**

```c++
#include <cstdint>

int main() {
  std::uint32_t value = 0x12345678;
  std::uint32_t cleared_value = value & ~0x00FF0000;  // Clear bits in a specific range
  return 0;
}
```

**15. Memory Alignment**

```c++
#include <cstdint>

int main() {
  std::aligned_storage<sizeof(int), std::alignment_of<int>::value> aligned_buffer;  // Create buffer with specified alignment
  return 0;
}
```

**16. Union Size**

```c++
#include <cstdint>

union Foo {
  std::int32_t a;
  std::int64_t b;
};

int main() {
  Foo foo;
  std::size_t size = sizeof(foo);  // Size of union is the size of its largest member
  return 0;
}
```

**17. Array Sizes**

```c++
#include <cstdint>

int main() {
  int array[10];
  std::size_t size = std::extent<decltype(array)>::value;  // Size of array in elements
  return 0;
}
```

**18. Function Pointers**

```c++
#include <cstdint>

int add(int a, int b) {
  return a + b;
}

int main() {
  typedef std::int32_t (*FunctionPtr)(std::int32_t, std::int32_t);  // Define function pointer type
  FunctionPtr func = add;  // Assign function to pointer
  return 0;
}
```

**19. Converting to/from Strings**

```c++
#include <cstdint>
#include <sstream>

int main() {
  std::uint64_t value = 12345;
  std::stringstream stream;
  stream << value;
  std::string value_string = stream.str();  // Convert integer to string
  return 0;
}
```

**20. Bitwise Shift Operations**

```c++
#include <cstdint>

int main() {
  std::int64_t value = 0x12345678;
  std::int64_t shifted_value = value << 3;  // Left shift by 3 bits
  return 0;
}
```

**21. Pointer Initialization**

```c++
#include <cstdint>

int main() {
  std::int32_t value;
  std::int32_t* pointer = &value;  // Initialize pointer to address of variable
  return 0;
}
```

**22. C-Style Arrays**

```c++
#include <cstdint>

int main() {
  int array[] = {1, 2, 3};
  std::size_t size = sizeof(array) / sizeof(int);  // Get size of C-style array
  return 0;
}
```

**23. Type Casting**

```c++
#include <cstdint>

int main() {
  std::int32_t value = 12345;
  std::int64_t casted_value = static_cast<std::int64_t>(value);  // Cast to a larger integer type
  return 0;
}
```

**24. Function Return Types**

```c++
#include <cstdint>

std::int64_t get_value() {
  return 12345;
}

int main() {
  std::int64_t value = get_value();  // Function returns a 64-bit integer
  return 0;
}
```

**25. STL Container Element Sizes**

```c++
#include <cstdint>
#include <vector>

int main() {
  std::vector<std::int64_t> vec;
  std::size_t element_size = sizeof(vec[0]);  // Size of element in STL container
  return 0;
}
```

**26. Memory Management**

```c++
#include <cstdint>
#include <memory>

int main() {
  std::unique_ptr<int> pointer = std::make_unique<int>(12345);  // Create and manage a dynamic integer
  return 0;
}
```

**27. Bitwise OR Operation**

```c++
#include <cstdint>

int main() {
  std::int32_t value1 = 0x1234;
  std::int32_t value2 = 0x5678;
  std::int32_t result = value1 | value2;  // Bitwise OR
  return 0;
}
```

**28. Bitwise AND Operation**

```c++
#include <cstdint>

int main() {
  std::int32_t value1 = 0x1234;
  std::int32_t value2 = 0x5678;
  std::int32_t result = value1 & value2;  // Bitwise AND
  return 0;
}
```

**29. Bitwise XOR Operation**

```c++
#include <cstdint>

int main() {
  std::int32_t value1 = 0x1234;
  std::int32_t value2 = 0x5678;
  std::int32_t result = value1 ^ value2;  // Bitwise XOR
  return 0;
}
```

**30. Bitwise NOT Operation**

```c++
#include <cstdint>

int main() {
  std::int32_t value = 0x1234;
  std::int32_t result = ~value;  // Bitwise NOT
  return 0;
}
```

**31. Bitwise Left Shift Operation**

```c++
#include <cstdint>

int main() {
  std::int32_t value = 0x1234;
  std::int32_t result = value << 4;  // Shift left by 4 bits
  return 0;
}
```

**32. Bitwise Right Shift Operation**

```c++
#include <cstdint>

int main() {
  std::int32_t value = 0x1234;
  std::int32_t result = value >> 4;  // Shift right by 4 bits
  return 0;
}
```

**33. Bitwise Left Rotate Operation**

```c++
#include <cstdint>

int main() {
  std::int32_t value = 0x1234;
  std::int32_t result = (value << 4) | (value >> 4);  // Left rotate by 4 bits
  return 0;
}
```

**34. Bitwise Right Rotate Operation**

```c++
#include <cstdint>

int main() {
  std::int32_t value = 0x1234;
  std::int32_t result = (value >> 4) | (value << 4);  // Right rotate by 4 bits
  return 0;
}
```

**35. Boolean Operations**

```c++
#include <cstdint>

int main() {
  bool a = true;
  bool b = false;
  bool result = a && b;  // Boolean AND
  return 0;
}
```

**36. Arithmetic Operations**

```c++
#include <cstdint>

int main() {
  std::int32_t a = 10;
  std::int32_t b = 5;
  std::int32_t result = a + b;  // Addition
  return 0;
}
```

**37. Relational Operations**

```c++
#include <cstdint>

int main() {
  std::int32_t a = 10;
  std::int32_t b = 5;
  bool result = a > b;  // Greater than
  return 0;
}
```

**38. Parentheses**

```c++
#include <cstdint>

int main() {
  std::int32_t a = 10;
  std::int32_t b = 5;
  std::int32_t result = ((a + b) * 2);  // Parentheses for grouping expressions
  return 0;
}
```

**39. Assignment**

```c++
#include <cstdint>

int main() {
  std::int32_t a = 10;
  std::int32_t b;
  b = a;  // Assignment
  return 0;
}
```

**40. Casting**

```c++
#include <cstdint>

int main() {
  std::int16_t a = 10;
  std::int32_t b;
  b = static_cast<std::int32_t>(a);  // Casting to a larger type
  return 0;
}
```

**41. Conditional**

```c++
#include <cstdint>

int main() {
  std::int32_t a = 10;
  std::int32_t b;
  b = (a > 5) ? 1 : 0;  // Conditional statement
  return 0;
}
```

**42. Loops**

```c++
#include <cstdint>

int main() {
  for (std::int32_t i = 0; i < 10; i++) {  // Loop
    // Do something
  }
  return 0;
}
```

**43. Arrays**

```c++
#include <cstdint>

int main() {
  std::int32_t a[10];  // Array
  a[0] = 10;
  return 0;
}
```

**44. Functions**

```c++
#include <cstdint>

std::int32_t sum(std::int32_t a, std::int32_t b) {
  return a + b;  // Function
}

int main() {
  std::int32_t result = sum(10, 5);  // Call function
  return 0;
}
```

**45. Pointers**

```c++
#include <cstdint>

int main() {
  std::int32_t a = 10;
  std::int32_t* ptr = &a;  // Pointer
  *ptr = 20;  // Dereference pointer
  return 0;
}
```

**46. Structures**

```c++
#include <cstdint>

struct Point {
  std::int32_t x;
  std::int32_t y;
};  // Structure

int main() {
  Point p;
  p.x = 10;
  p.y = 20;
  return 0;
}
```

**47. Unions**

```c++
#include <cstdint>

union MyUnion {
  std::int32_t a;
  std::int64_t b;
};  // Union

int main() {
  MyUnion u;
  u.a = 10;
  u.b = 20;
  return 0;
}
```

**48. Bit Fields**

```c++
#include <cstdint>

struct Flags {
  std::uint8_t flag1 : 1;
  std::uint8_t flag2 : 1;
};  // Bit field

int main() {
  Flags f;
  f.flag1 = true;
  return 0;
}
```

**49. Type Aliases**

```c++
#include <cstdint>

typedef std::int64_t BigInt;  // Type alias

int main() {
  BigInt a = 10;
  return 0;
}
```

**50. Macros**

```c++
#include <cstdint>

#define MAX_VALUE 100  // Macro

int main() {
  std::int32_t a = MAX_VALUE;
  return 0;
}
```