# charconv

***

**1. Convert Integer to String**

```cpp
#include <charconv>
#include <string>

int main() {
  int num = 123;
  std::string str;
  std::to_chars(str, num);
  std::cout << str << std::endl; // Output: "123"
}
```

**2. Convert String to Integer**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string str = "123";
  int num;
  std::from_chars(str.data(), str.data() + str.size(), num);
  std::cout << num << std::endl; // Output: 123
}
```

**3. Convert Floating-point to String**

```cpp
#include <charconv>
#include <string>

int main() {
  float num = 123.45;
  std::string str;
  std::to_chars(str, num);
  std::cout << str << std::endl; // Output: "123.45"
}
```

**4. Convert String to Floating-point**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string str = "123.45";
  float num;
  std::from_chars(str.data(), str.data() + str.size(), num);
  std::cout << num << std::endl; // Output: 123.45
}
```

**5. Convert Signed Integer to String**

```cpp
#include <charconv>
#include <string>

int main() {
  int num = -123;
  std::string str;
  std::to_chars(str, num);
  std::cout << str << std::endl; // Output: "-123"
}
```

**6. Convert String to Signed Integer**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string str = "-123";
  int num;
  std::from_chars(str.data(), str.data() + str.size(), num);
  std::cout << num << std::endl; // Output: -123
}
```

**7. Convert Hexadecimal String to Integer**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string str = "0x123";
  int num;
  std::from_chars(str.data(), str.data() + str.size(), num, 16);
  std::cout << num << std::endl; // Output: 291
}
```

**8. Convert Integer to Hexadecimal String**

```cpp
#include <charconv>
#include <string>

int main() {
  int num = 291;
  std::string str;
  std::to_chars(str, num, 16);
  std::cout << str << std::endl; // Output: "123"
}
```

**9. Convert Binary String to Integer**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string str = "0b10010011";
  int num;
  std::from_chars(str.data(), str.data() + str.size(), num, 2);
  std::cout << num << std::endl; // Output: 151
}
```

**10. Convert Integer to Binary String**

```cpp
#include <charconv>
#include <string>

int main() {
  int num = 151;
  std::string str;
  std::to_chars(str, num, 2);
  std::cout << str << std::endl; // Output: "10010011"
}
```

**11. Handle Conversion Errors (Integer)**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string str = "abc";
  int num;
  auto res = std::from_chars(str.data(), str.data() + str.size(), num);
  if (res.ec == std::errc::invalid_argument) {
    // Conversion failed due to invalid input
  }
}
```

**12. Handle Conversion Errors (Floating-point)**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string str = "abc";
  float num;
  auto res = std::from_chars(str.data(), str.data() + str.size(), num);
  if (res.ec == std::errc::invalid_argument) {
    // Conversion failed due to invalid input
  }
}
```

**13. Use stream-style interface (Integer)**

```cpp
#include <charconv>
#include <sstream>

int main() {
  int num = 123;
  std::stringstream ss;
  ss << std::hex << num;
  std::cout << ss.str() << std::endl; // Output: "7b"
}
```

**14. Use stream-style interface (Floating-point)**

```cpp
#include <charconv>
#include <sstream>

int main() {
  float num = 123.45;
  std::stringstream ss;
  ss << std::fixed << num;
  std::cout << ss.str() << std::endl; // Output: "123.450000"
}
```

**15. Convert Integer to String with Leading Zeros**

```cpp
#include <charconv>
#include <string>

int main() {
  int num = 123;
  std::string str;
  std::to_chars(str, num, 10, std::chars_format::left, '0', 6);
  std::cout << str << std::endl; // Output: "000123"
}
```

**16. Convert String to Integer with Leading Zeros**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string str = "000123";
  int num;
  std::from_chars(str.data(), str.data() + str.size(), num, 10, std::chars_format::left, '0', 6);
  std::cout << num << std::endl; // Output: 123
}
```

**17. Convert Integer to String with Trailing Zeros**

```cpp
#include <charconv>
#include <string>

int main() {
  int num = 123;
  std::string str;
  std::to_chars(str, num, 10, std::chars_format::right, '0', 6);
  std::cout << str << std::endl; // Output: "123000"
}
```

**18. Convert String to Integer with Trailing Zeros**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string str = "123000";
  int num;
  std::from_chars(str.data(), str.data() + str.size(), num, 10, std::chars_format::right, '0', 6);
  std::cout << num << std::endl; // Output: 123
}
```

**19. Convert Integer to String with Thousand Separator**

```cpp
#include <charconv>
#include <string>
#include <locale>

int main() {
  int num = 1234567;
  std::string str;
  std::to_chars(str, num, std::locale("en_US.UTF-8"));
  std::cout << str << std::endl; // Output: "1,234,567"
}
```

**20. Convert String to Integer with Thousand Separator**

```cpp
#include <charconv>
#include <string>
#include <locale>

int main() {
  std::string str = "1,234,567";
  int num;
  std::from_chars(str.data(), str.data() + str.size(), num, std::locale("en_US.UTF-8"));
  std::cout << num << std::endl; // Output: 1234567
}
```

**21. Convert Integer to String with Local Format**

```cpp
#include <charconv>
#include <string>
#include <locale>

int main() {
  int num = 1234567;
  std::string str;
  std::to_chars(str, num, std::locale("fr_FR.UTF-8"));
  std::cout << str << std::endl; // Output: "1 234 567"
}
```

**22. Convert String to Integer with Local Format**

```cpp
#include <charconv>
#include <string>
#include <locale>

int main() {
  std::string str = "1 234 567";
  int num;
  std::from_chars(str.data(), str.data() + str.size(), num, std::locale("fr_FR.UTF-8"));
  std::cout << num << std::endl; // Output: 1234567
}
```

**23. Parse JSON Value as Integer**

```cpp
#include <charconv>
#include <string>
#include <sstream>
#include <json.hpp>

int main() {
  std::string jsonStr = "{\"num\": 123}";
  auto json = nlohmann::json::parse(jsonStr);
  int num;
  std::stringstream ss(json["num"].get<std::string>());
  std::from_chars(ss.str().data(), ss.str().data() + ss.str().size(), num);
  std::cout << num << std::endl; // Output: 123
}
```

**24. Parse CSV Value as Float**

```cpp
#include <charconv>
#include <string>
#include <sstream>
#include <fstream>

int main() {
  std::ifstream csvFile("data.csv");
  std::string line;
  while (std::getline(csvFile, line)) {
    std::stringstream ss(line);
    std::string token;
    while (std::getline(ss, token, ',')) {
      float value;
      std::from_chars(token.data(), token.data() + token.size(), value);
      std::cout << value << std::endl; // Output: Each float value in the CSV file
    }
  }
}
```

**25. Convert Money Amount to String with Currency Symbol**

```cpp
#include <charconv>
#include <string>

struct Money {
  double amount;
  std::string currency;
};

std::string to_string(const Money& money) {
  std::string str;
  std::to_chars(str, money.amount);
  str += " " + money.currency;
  return str;
}

int main() {
  Money money = {123.45, "USD"};
  std::cout << to_string(money) << std::endl; // Output: "123.45 USD"
}
```

**26. Convert Duration to String with Human-Readable Format**

```cpp
#include <charconv>
#include <string>
#include <chrono>

std::string to_string(const std::chrono::duration<double>& duration) {
  std::string str;
  int hours = std::chrono::duration_cast<std::chrono::hours>(duration).count();
  int minutes = std::chrono::duration_cast<std::chrono::minutes>(duration % std::chrono::hours(1)).count();
  int seconds = std::chrono::duration_cast<std::chrono::seconds>(duration % std::chrono::minutes(1)).count();
  std::to_chars(str, hours);
  str += ":";
  std::to_chars(str, minutes);
  str += ":";
  std::to_chars(str, seconds);
  return str;
}

int main() {
  std::chrono::duration<double> duration = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::hours(1) + std::chrono::minutes(23) + std::chrono::seconds(45));
  std::cout << to_string(duration) << std::endl; // Output: "01:23:45"
}
```

**27. Convert Date to String with ISO 8601 Format**

```cpp
#include <charconv>
#include <string>
#include <ctime>

std::string to_string(const std::tm& date) {
  std::string str;
  std::to_chars(str, date.tm_year + 1900);  // Year
  str += '-';
  std::to_chars(str, date.tm_mon + 1);     // Month
  str += '-';
  std::to_chars(str, date.tm_mday);      // Day
  str += 'T';
  std::to_chars(str, date.tm_hour);       // Hour
  str += ':';
  std::to_chars(str, date.tm_min);       // Minute
  str += ':';
  std::to_chars(str, date.tm_sec);       // Second
  return str;
}

int main() {
  std::time_t now = std::time(nullptr);
  std::tm* date = std::localtime(&now);
  std::cout << to_string(*date) << std::endl; // Output: "2023-03-08T15:37:23"
}
```

**28. Parse String to Custom Object with Embedded Conversion**

```cpp
#include <charconv>
#include <string>

struct Person {
  std::string name;
  int age;
};

Person from_string(const std::string& str) {
  std::string name;
  int age;
  std::from_chars(str.data(), str.data() + str.find(','), name);
  std::from_chars(str.data() + str.find(',') + 1, str.data() + str.size(), age);
  return Person{name, age};
}

int main() {
  std::string str = "John Doe,30";
  Person person = from_string(str);
  std::cout << person.name << ", " << person.age << std::endl; // Output: "John Doe, 30"
}
```

**29. Perform Dynamic Conversion with Switch-Case**

```cpp
#include <charconv>
#include <string>
#include <vector>

std::string to_string(const std::any& value) {
  std::string str;
  if (value.type() == typeid(int)) {
    std::to_chars(str, std::any_cast<int>(value));
  } else if (value.type() == typeid(double)) {
    std::to_chars(str, std::any_cast<double>(value));
  } else if (value.type() == typeid(std::string)) {
    str = std::any_cast<std::string>(value);
  } else {
    throw std::invalid_argument("Unsupported type");
  }
  return str;
}

int main() {
  std::vector<std::any> values = {123, 123.45, "abc"};
  for (const auto& value : values) {
    std::cout << to_string(value) << std::endl; // Output: "123", "123.45", "abc"
  }
}
```

**30. Perform Flexible Conversion with Variadic Templates**

```cpp
#include <charconv>
#include <string>
#include <tuple>

template <typename T>
std::string to_string(const T& value) {
  std::string str;
  std::to_chars(str, value);
  return str;
}

template <typename First, typename... Rest>
std::string to_string(const First& first, const Rest&... rest) {
  return to_string(first) + ", " + to_string(rest...);
}

int main() {
  std::cout << to_string(123, 123.45, "abc") << std::endl; // Output: "123, 123.45, abc"
}
```

**31. Handle Narrowing Conversions with saturating\_cast**

```cpp
#include <charconv>
#include <string>
#include <limits>

int main() {
  std::string str = "123456789";
  int32_t num = std::numeric_limits<int32_t>::max();
  std::from_chars(str.data(), str.data() + str.size(), num);
  std::cout << num << std::endl; // Output: 2147483647 (max value of int32_t)
}
```

**32. Convert Character to Integer**

```cpp
#include <charconv>
#include <string>

int main() {
  char c = 'a';
  int num;
  std::from_chars(&c, &c + 1, num);
  std::cout << num << std::endl; // Output: 97 (ASCII value of 'a')
}
```

**33. Convert Byte String to Integer**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string bytes = "01001101";
  int num;
  std::from_chars(bytes.data(), bytes.data() + bytes.size(), num, 2);
  std::cout << num << std::endl; // Output: 77
}
```

**34. Convert Float to String with Fixed Precision**

```cpp
#include <charconv>
#include <string>

int main() {
  float num = 123.456789;
  std::string str;
  std::to_chars(str, num, std::fixed, 2);
  std::cout << str << std::endl; // Output: "123.46"
}
```

**35. Convert String to Float with Explicit Radix**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string str = "123.456789";
  float num;
  std::from_chars(str.data(), str.data() + str.size(), num, 10);
  std::cout << num << std::endl; // Output: 123.456789
}
```

**36. Perform Integer-to-String Conversion with Padding**

```cpp
#include <charconv>
#include <string>

int main() {
  int num = 123;
  std::string str;
  std::to_chars(str, num, 10, std::chars_format::left, '0', 6);
  std::cout << str << std::endl; // Output: "000123"
}
```

**37. Convert Number to String with Scientific Notation**

```cpp
#include <charconv>
#include <string>

int main() {
  double num = 123.456789;
  std::string str;
  std::to_chars(str, num, std::chars_format::scientific);
  std::cout << str << std::endl; // Output: "1.23456789e+02"
}
```

**38. Convert String to Number with Legacy Conversion Functions**

```cpp
#include <string>
#include <sstream>
#include <cstring>

int main() {
  std::string str = "123.45";
  int num;
  std::istringstream ss(str);
  ss >> num;
  std::cout << num << std::endl; // Output: 123
}
```

**39. Convert Number to String in a C-style Format**

```cpp
#include <stdio.h>

int main() {
  int num = 123;
  char str[10];
  sprintf(str, "%d", num);
  std::cout << str << std::endl; // Output: "123"
}
```

**40. Convert String to Number in a C-style Format**

```cpp
#include <stdio.h>

int main() {
  char str[] = "123.45";
  double num;
  sscanf(str, "%lf", &num);
  std::cout << num << std::endl; // Output: 123.45
}
```

**41. Convert Number to String with Hexadecimal Format**

```cpp
#include <sstream>

int main() {
  int num = 123;
  std::stringstream ss;
  ss << std::hex << num;
  std::cout << ss.str() << std::endl; // Output: "7b"
}
```

**42. Convert String to Number with Octal Format**

```cpp
#include <sstream>

int main() {
  std::string str = "177";
  int num;
  std::stringstream ss(str);
  ss >> std::oct >> num;
  std::cout << num << std::endl; // Output: 127
}
```

**43. Perform String-to-Number Conversion with Robustness**

```cpp
#include <string>
#include <sstream>

bool try_convert_int(const std::string& str, int& num) {
  std::istringstream ss(str);
  return (ss >> num) && (ss.eof() || ss.get() == ' ');
}

int main() {
  std::string str = "123 abc";
  int num;
  if (try_convert_int(str, num)) {
    std::cout << "Conversion successful: " << num << std::endl;
  } else {
    std::cout << "Conversion failed" << std::endl;
  }
}
```

**44. Convert String to Number with Explicit Error Handling**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string str = "123.45";
  int num;
  auto res = std::from_chars(str.data(), str.data() + str.size(), num);
  if (res.ec == std::errc{}) {
    std::cout << "Conversion successful: " << num << std::endl;
  } else {
    std::cout << "Conversion failed: " << res.ec.message() << std::endl;
  }
}
```

**45. Perform Integer-to-String Conversion with Locale-Aware Formatting**

```cpp
#include <charconv>
#include <string>
#include <locale>

int main() {
  int num = 1234567;
  std::locale::global(std::locale("fr_FR.UTF-8"));
  std::string str;
  std::to_chars(str, num, std::locale());
  std::cout << str << std::endl; // Output: "1 234 567"
}
```

**46. Convert String to Number with Locale-Aware Parsing**

```cpp
#include <charconv>
#include <string>
#include <locale>

int main() {
  std::string str = "1 234 567";
  std::locale::global(std::locale("fr_FR.UTF-8"));
  int num;
  std::from_chars(str.data(), str.data() + str.size(), num, std::locale());
  std::cout << num << std::endl; // Output: 1234567
}
```

**47. Perform String-to-Number Conversion with Custom Delimiters**

```cpp
#include <string>
#include <sstream>
#include <vector>

std::vector<int> split_and_convert(const std::string& str, char delimiter) {
  std::vector<int> numbers;
  std::stringstream ss(str);
  int num;
  while (ss >> num) {
    numbers.push_back(num);
    if (ss.peek() == delimiter) {
      ss.ignore();
    }
  }
  return numbers;
}

int main() {
  std::string str = "123,456,789";
  std::vector<int> numbers = split_and_convert(str, ',');
  for (const auto& num : numbers) {
    std::cout << num << " "; // Output: 123 456 789
  }
  std::cout << std::endl;
}
```

**48. Convert Integer to String with Comma Separators**

```cpp
#include <charconv>
#include <string>
#include <sstream>

std::string to_string_with_commas(int num) {
  std::stringstream ss;
  ss << std::fixed << std::commas << num;
  return ss.str();
}

int main() {
  int num = 1234567;
  std::string str = to_string_with_commas(num);
  std::cout << str << std::endl; // Output: "1,234,567"
}
```

**49. Perform Bitwise Conversion with to\_integer**

```cpp
#include <charconv>
#include <string>

int main() {
  std::string binaryStr = "101101";
  int num;
  std::from_chars(binaryStr.data(), binaryStr.data() + binaryStr.size(), num, 2);
  std::cout << num << std::endl; // Output: 45
}
```

**50. Convert Number to String with Leading Sign**

```cpp
#include <charconv>
#include <string>

int main() {
  int num = -123;
  std::string str;
  std::to_chars(str, num, std::chars_format::showbase);
  std::cout << str << std::endl; // Output: "-123"
}
```