# cinttypes

***

**1. Parsing Integer String Input**

```cpp
#include <cinttypes>

int main() {
    char input[] = "12345";
    uint32_t value;
    sscanf(input, "%" SCNu32, &value);
    std::cout << "Value: " << value << std::endl;
    return 0;
}
```

**2. Formatting Integer Output**

```cpp
#include <cinttypes>

int main() {
    uint64_t value = 1234567890123456789;
    char buffer[64];
    snprintf(buffer, sizeof(buffer), "%" PRIu64, value);
    std::cout << "Formatted value: " << buffer << std::endl;
    return 0;
}
```

**3. Reading Integer from Binary File**

```cpp
#include <cinttypes>
#include <fstream>

int main() {
    std::ifstream file("data.bin", std::ios::binary);
    uint16_t value;
    file.read((char*)&value, sizeof(uint16_t));
    std::cout << "Value from binary file: " << value << std::endl;
    return 0;
}
```

**4. Writing Integer to Binary File**

```cpp
#include <cinttypes>
#include <fstream>

int main() {
    std::ofstream file("data.bin", std::ios::binary);
    uint32_t value = 123456;
    file.write((char*)&value, sizeof(uint32_t));
    std::cout << "Value written to binary file" << std::endl;
    return 0;
}
```

**5. Sizeof Integer Types**

```cpp
#include <cinttypes>

int main() {
    std::cout << "Size of int8_t: " << sizeof(int8_t) << std::endl;
    std::cout << "Size of uint8_t: " << sizeof(uint8_t) << std::endl;
    std::cout << "Size of int16_t: " << sizeof(int16_t) << std::endl;
    std::cout << "Size of uint16_t: " << sizeof(uint16_t) << std::endl;
    return 0;
}
```

**6. Minimum and Maximum Values of Integer Types**

```cpp
#include <cinttypes>
#include <limits>

int main() {
    std::cout << "Minimum value of int8_t: " << std::numeric_limits<int8_t>::min() << std::endl;
    std::cout << "Maximum value of uint8_t: " << std::numeric_limits<uint8_t>::max() << std::endl;
    std::cout << "Minimum value of int16_t: " << std::numeric_limits<int16_t>::min() << std::endl;
    std::cout << "Maximum value of uint16_t: " << std::numeric_limits<uint16_t>::max() << std::endl;
    return 0;
}
```

**7. Converting Integer Types**

```cpp
#include <cinttypes>

int main() {
    uint32_t value = 12345;
    int16_t converted_value = static_cast<int16_t>(value);
    std::cout << "Converted value: " << converted_value << std::endl;
    return 0;
}
```

**8. Bit Manipulation**

```cpp
#include <cinttypes>

int main() {
    uint32_t value = 0x12345678;
    value |= 0x00000001;    // Set the least significant bit
    value &= 0xFFFFFFFE;    // Clear the least significant bit
    std::cout << "Bit-manipulated value: " << value << std::endl;
    return 0;
}
```

**9. Fast Integer Arithmetic**

```cpp
#include <cinttypes>

int main() {
    uint64_t a = 1234567890123456789;
    uint64_t b = 9876543210987654321;
    uint64_t result = a + b;
    std::cout << "Fast integer arithmetic result: " << result << std::endl;
    return 0;
}
```

**10. Atomic Operations**

```cpp
#include <cinttypes>
#include <atomic>

int main() {
    std::atomic<uint32_t> counter(0);
    counter.fetch_add(1);    // Atomically increment the counter
    std::cout << "Atomic counter value: " << counter << std::endl;
    return 0;
}
```

**11. Integer Constants**

```cpp
#include <cinttypes>

int main() {
    int8_t value = INT8_MIN;    // Integer constant for minimum 8-bit integer
    uint16_t value = UINT16_MAX;    // Integer constant for maximum 16-bit integer
    std::cout << "Integer constant value: " << value << std::endl;
    return 0;
}
```

**12. Checking Integer Overflow**

```cpp
#include <cinttypes>

int main() {
    uint32_t a = 0xFFFFFFFF;
    uint32_t b = 1;
    bool overflow = __builtin_add_overflow(a, b, &a);
    if (overflow) {
        std::cout << "Integer overflow occurred" << std::endl;
    } else {
        std::cout << "Integer overflow did not occur" << std::endl;
    }
    return 0;
}
```

**13. Reading Integer from Command Line**

```cpp
#include <cinttypes>

int main(int argc, char** argv) {
    if (argc < 2) {
        std::cout << "Usage: <program> <integer>" << std::endl;
        return 1;
    }

    uint64_t value = std::stoull(argv[1]);
    std::cout << "Integer from command line: " << value << std::endl;
    return 0;
}
```

**14. Printing Integer in Hexadecimal Format**

```cpp
#include <cinttypes>

int main() {
    uint32_t value = 0x12345678;
    printf("Hexadecimal value: %" PRIx32 "\n", value);
    return 0;
}
```

**15. Maximum and Minimum Values of Types**

```cpp
#include <cinttypes>
#include <limits>

int main() {
    std::cout << "Maximum value of int32_t: " << std::numeric_limits<int32_t>::max() << std::endl;
    std::cout << "Minimum value of int32_t: " << std::numeric_limits<int32_t>::min() << std::endl;
    std::cout << "Maximum value of uint64_t: " << std::numeric_limits<uint64_t>::max() << std::endl;
    std::cout << "Minimum value of uint64_t: " << std::numeric_limits<uint64_t>::min() << std::endl;
    return 0;
}
```

**16. Integer Division with Truncation**

```cpp
#include <cinttypes>

int main() {
    int64_t a = 123456;
    int64_t b = 10;
    int64_t result = a / b;    // integer division truncates the result
    std::cout << "Integer division result: " << result << std::endl;
    return 0;
}
```

**17. Integer Division with Remainder**

```cpp
#include <cinttypes>

int main() {
    int64_t a = 123456;
    int64_t b = 10;
    int64_t remainder;
    int64_t result = lldiv(a, b, &remainder);    // returns quotient in result and remainder in remainder
    std::cout << "Integer division with remainder: quotient=" << result << ", remainder=" << remainder << std::endl;
    return 0;
}
```

**18. Signed Integer Overflow Detection**

```cpp
#include <cinttypes>

int main() {
    int8_t a = 127;
    a = a + 1;    // overflow occurs here
    std::cout << "Signed integer overflow result: " << (int)a << std::endl;    // prints -128
    return 0;
}
```

**19. Unsigned Integer Overflow Detection**

```cpp
#include <cinttypes>

int main() {
    uint8_t a = 255;
    a = a + 1;    // overflow occurs here
    std::cout << "Unsigned integer overflow result: " << (int)a << std::endl;    // prints 0

```