cstdint

---

1. Integer Constant Ranges

#include <cstdint>

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

2. Fixed-Size Integers

#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

#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

#include <cstdint>

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

5. Maximum and Minimum Values

#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

#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

#include <cstdint>

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

8. Enumerated Types

#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

#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

#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

#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

#include <cstdint>

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

13. Address Calculations

#include <cstdint>

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

14. Bit Manipulation

#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

#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

#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

#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

#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

#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

#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

#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

#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

#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

#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

#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

#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

#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

#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

#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

#include <cstdint>

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

31. Bitwise Left Shift Operation

#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

#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

#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

#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

#include <cstdint>

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

36. Arithmetic Operations

#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

#include <cstdint>

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

38. Parentheses

#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

#include <cstdint>

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

40. Casting

#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

#include <cstdint>

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

42. Loops

#include <cstdint>

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

43. Arrays

#include <cstdint>

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

44. Functions

#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

#include <cstdint>

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

46. Structures

#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

#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

#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

#include <cstdint>

typedef std::int64_t BigInt;  // Type alias

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

50. Macros

#include <cstdint>

#define MAX_VALUE 100  // Macro

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