Merge branch 'master' into patch-1-negative-minimum-value

pull/1/head
Clyne 4 years ago committed by GitHub
commit a7dd0243fe
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -5,7 +5,7 @@
* Convert any integral type to a string at compile-time
* Supports converting to any base between 2 and 36 inclusive
* No external dependencies, only includes `type_traits` for template parameter checking
* Works best in C++20 GCC or C++17/20 Clang
* Supports custom character types, e.g. `to_string<123, 10, wchar_t>`
**How to use:**
@ -22,31 +22,31 @@ With `to_string`, all that will be found in program disassembly are the resultin
Try it [on Compiler Explorer](https://godbolt.org/z/T-MFoh).
**Known issues:**
* With C++17 GCC, `to_string` must be used to initialize variables; otherwise, the integer-string conversion is done at run-time.
# How it works
The basic structure of `to_string` is shown below:
```cpp
template<auto N, unsigned int base, /* N type-check and base bounds-check */>
template<auto N, unsigned int base, typename char_type, /* N type-check and base bounds-check */>
struct to_string_t {
char buf[]; // Size selection explained later.
constexpr to_string_t() {} // Converts the integer to a string stored in buf.
constexpr operator char *() {} // These allow for the object to be implicitly converted
constexpr operator const char *() {} // to a character pointer.
char_type buf[]; // Size selection explained later.
constexpr to_string_t() {} // Converts the integer to a string stored in buf.
constexpr operator char_type *() {} // These allow for the object to be implicitly converted
constexpr operator const char_type *() {} // to a character pointer.
// begin() and end() are supported too.
};
template<auto N, unsigned int base = 10>
to_string_t<N, base> to_string; // Simplifies usage: to_string_t<N, base>() becomes to_string<N, base>.
template<auto N, unsigned int base = 10, typename char_type = char>
constexpr to_string_t<N, base, char_type> to_string; // Simplifies usage, e.g. to_string_t<367>() becomes to_string<367>.
```
Since the number and base are template parameters, each differing `to_string` use will get its own character buffer.
The integer/string conversion is done using a simple method I learned over the years, where the string is built in reverse using `n % base` to calculate the value of the lowest digit:
(*Note: The below examples of code are not up-to-date, though they still give a general idea of how `to_string` works.*)
```cpp
constexpr to_string_t() {
auto ptr = buf + sizeof(buf) / sizeof(buf[0]);

@ -15,49 +15,60 @@
* @tparam N Number to convert
* @tparam base Desired base, can be from 2 to 36
*/
template<auto N, unsigned int base,
template<auto N, unsigned int base, typename char_type,
std::enable_if_t<std::is_integral_v<decltype(N)>, int> = 0,
std::enable_if_t<(base > 1 && base < 37), int> = 0>
struct to_string_t {
class to_string_t {
// The lambda calculates what the string length of N will be, so that `buf`
// fits to the number perfectly.
char buf[([] {
unsigned int len = N >= 0 ? 1 : 2;
for (auto n = N; n; len++, n /= base);
return len;
}())];
char_type buf[([]() constexpr noexcept {
unsigned int len = N > 0 ? 1 : 2;
for (auto n = N; n; len++, n /= base);
return len;
}())] = {};
public:
/**
* Constructs the object, filling `buf` with the string representation of N.
*/
constexpr to_string_t() {
auto ptr = buf + sizeof(buf) / sizeof(buf[0]);
constexpr to_string_t() noexcept {
auto ptr = end();
*--ptr = '\0';
for (auto n = N; n; n /= base)
*--ptr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[(N < 0 ? -1 : 1) * (n % base)];
if (N < 0)
*--ptr = '-';
if (N != 0) {
for (auto n = N < 0 ? -N : N; n; n /= base)
*--ptr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[(N < 0 ? -1 : 1) * (n % base)];
if (N < 0)
*--ptr = '-';
} else {
buf[0] = '0';
}
}
/**
* Allows implicit conversion of this object to a `char *`.
*/
constexpr operator char *() {
return buf;
}
/**
* Allows implicit conversion of this object to a `const char *`.
*/
constexpr operator const char *() const {
return buf;
}
// Support implicit casting to `char *` or `const char *`.
constexpr operator char_type *() noexcept { return buf; }
constexpr operator const char_type *() const noexcept { return buf; }
constexpr auto size() const noexcept { return sizeof(buf) / sizeof(buf[0]); }
// Element access
constexpr auto data() noexcept { return buf; }
constexpr const auto data() const noexcept { return buf; }
constexpr auto& operator[](unsigned int i) noexcept { return buf[i]; }
constexpr const auto& operator[](unsigned int i) const noexcept { return buf[i]; }
constexpr auto& front() noexcept { return buf[0]; }
constexpr const auto& front() const noexcept { return buf[0]; }
constexpr auto& back() noexcept { return buf[size() - 1]; }
constexpr const auto& back() const noexcept { return buf[size() - 1]; }
// Iterators
constexpr auto begin() noexcept { return buf; }
constexpr const auto begin() const noexcept { return buf; }
constexpr auto end() noexcept { return buf + size(); }
constexpr const auto end() const noexcept { return buf + size(); }
};
/**
* Simplifies use of `to_string_t` from `to_string_t<N>()` to `to_string<N>`.
*/
template<auto N, unsigned int base = 10>
to_string_t<N, base> to_string;
template<auto N, unsigned int base = 10, typename char_type = char>
constexpr to_string_t<N, base, char_type> to_string;
#endif // TCSULLIVAN_TO_STRING_HPP_

Loading…
Cancel
Save