unterumarmung / fixed_string

C++17 string with fixed size

fixed_string

C++ library that provides a basic_fixed_string template that combines std::array fixed-size semantic and std::string semantic together

Features

• C++17 or higher
• Header-only
• Dependency-free
• No dynamic allocations
• Fully constexpr
• Can be used as class non-type template parameter (since C++20)

Examples

• Construction

constexpr fixstr::fixed_string foo = "foo";

• Concatenation

using namespace fixstr;
constexpr fixed_string first = "Hello, ";
constexpr fixed_string second = "World!";
constexpr auto result = first + second; // "Hello, World!"

• Comparison

using namespace fixstr;
constexpr fixed_string first = "Hello, ";
constexpr fixed_string second = "World!";
static_assert(first == second); // false
static_assert(first != second); // true
static_assert(first < second);  // true
static_assert(first <= second); // true
static_assert(first > second);  // false 
static_assert(first >= second); // false
static_assert(first <=> second != 0); // true

• Non-type template parameter

template <fixstr::fixed_string Foo>
void bar()
{
    static_assert(Foo == "foo"sv);
}

void foo()
{
    bar<"foo">();
}

Integration

Since it's a header only library, you need just copy fixed_string.hpp to your project.

If you are using vcpkg on your project for external dependencies, then you can use the fixed-string package.

If you are using Conan on your project for external dependencies, then you can use the Conan recipe located in the root of the repository.

Compiler compatibility

• GCC >= 7.3
• Clang >= 5
• ICC >= 19.0.1
• MSVC >= 14.28 / Visual Studio 2019 (I don't have access to older VS versions right now, so it can work on older versions too)

Using basic_fixed_string as class non-type template parameter full available in GCC >= 10 and VS 2019 16.9 or newer

fixed_string's Issues

Add clang-tidy checks to CI

It needs to be done after issue #22

Add spellchecker to CI

Example: https://github.com/oneapi-src/oneTBB/blob/master/.github/workflows/ci.yml#L33-L42

Add `operator+=`

The current version of the fixed_string doesn't have operator+= overload but it has to.
Additionally, after implementing operator+= we can refactor operator+ overload for basic_fixed_string argument.

to char* issue

https://github.com/JustasMasiulis/xorstr
constexpr fixstr::fixed_string foo = xor ("foo"); // error because is not const char*

So it doesn't works, fix it.

Revise default constructor implementation

Current implementation of default constructor looks like this:

fixed_string/include/fixed_string.hpp

Line 122 in 6a5b2f5

constexpr basic_fixed_string() noexcept { details::fill(_data.begin(), _data.end(), static_cast<value_type>(0)); }

It can be reimplemented like this

constexpr basic_fixed_string() = default;

or even it can be not user-provided if compiler is able to generate it

Add `static_assert`s for template parameters of `basic_fixed_string`

Example from implementation of basic_string_view by Microsoft: https://github.com/microsoft/STL/blob/main/stl/inc/xstring#L1224-L1230

CI: attach built documentation to the PR check

Use https://github.com/actions/upload-artifact to implement the functionality

Move `data` definition

In the current version data member function is in string operations section but it should be in element access one

fixed_string/include/fixed_string.hpp

Lines 215 to 217 in 6a5b2f5

	// string operations
	[[nodiscard]] constexpr pointer data() noexcept { return _data.data(); }
	[[nodiscard]] constexpr const_pointer data() const noexcept { return _data.data(); }

Update cNTTP support

Since November 2020 all compilers started to support class non-type template parameters.

Conan recipe.

For easy integration with projects, it is good to have a conan recipe.

Documentation

API Reference

• Constructors
• operator=
• at
• front
• back
• empty
• size & length
• max_size
• begin & cbegin
• end & cend
• rbegin & crbegin
• rend & crend
• data
• c_str
• String view conversion operator
• substr
• find
• rfind
• find_first_of
• find_last_of
• find_first_not_of
• find_last_not_of
• compare
• starts_with
• ends_with
• contains
• swap
• Comparison operators
• operator+
• Hashing

Add `.c_str()`

It can just call .data()

• Add implementation
• Add documentation
• Add tests

Support for C++11

It would be nice if you could make this class C++11-compatible. Many of us are stuck using older versions of the language standard...

Obviously, this will mean some constexpr members may need to become CONSTEXPR_SINCE_CPP14 or CONSTEXPR_SINCE_CPP17; and you may need to drop std::array which is pre-constexpr'ed in C++11. But it's still worth it IMHO :-) ... a bit of preprocessor magic can make it happen.

Implement strings for specific TChar types without inheritance

Using type aliases instead of inheritance makes it possible to generalize the algorithm templates for all specializations of fixstr::basic_fixed_string.

For example (see also p1406r1):

namespace std
{
template <typename TChar,
          std::size_t N,
          typename TTraits>
struct hash<fixstr::basic_fixed_string<TChar, N, TTraits>>
{
    using argument_type = fixstr::basic_fixed_string<TChar, N, TTraits>;
    size_t operator()(const argument_type& str) const
    {
        using sv_t = typename argument_type::string_view_type;
        return std::hash<sv_t>()(static_cast<sv_t>(str));
    }
};
} // namespace std

Refactor tests

Currently tests are placed in one file which is not very convenient.

The proposed solution is to separate tests to files by some logical pieces: for example, a file per a member function or a piece of functionality (e.g. hash support, string operations, etc.)

constructor from any const char* and std::string

You can't construct a fixed string from anything other than fixed strings or char[N] where N is the same size as the fixed string's size.
It would be great to have convenience constructors that take any string and just truncate them.

Add numeric conversions

Suggested API:

    // numeric conversions
    template <size_t N>
    constexpr int stoi(const fixed_string<N>& str, int base = 10);
    
    template <size_t N>
    constexpr unsigned stou(const fixed_string<N>& str, int base = 10);
    
    template <size_t N>
    constexpr long stol(const fixed_string<N>& str, int base = 10);
    
    template <size_t N>
    constexpr unsigned long stoul(const fixed_string<N>& str, int base = 10);
    
    template <size_t N>
    constexpr long long stoll(const fixed_string<N>& str, int base = 10);
    
    template <size_t N>
    constexpr unsigned long long stoull(const fixed_string<N>& str, int base = 10);
    
    template <size_t N>
    constexpr float stof(const fixed_string<N>& str);
    
    template <size_t N>
    constexpr double stod(const fixed_string<N>& str);
    
    template <size_t N>
    constexpr long double stold(const fixed_string<N>& str);
    
    template <auto val> // where decltype(val) is an integral type but not any of char types
    constexpr fixed_string</*...*/> to_fixed_string() noexcept;

Proposed implementation: using to_chars and from_chars from <charconv>
Known issues: cannot be really constexpr

• Create implementation
• Create tests
• Add docs

Try Rule of 0

Try to implement Rule of 0:

• Delete copy constructor and operator= (only for basic_fixed_string).

If not possible - implement Rule of 5:

• Add if (&other != this) check for copy operator= to eliminate excessive copies
• Make move constructor and operator= explicitly defaulted
• Make destructor explicitly defaulted

Remove CLion's `.idea` folder that contains code style checks

Clang-Tidy allows to specify code style settings in a config file, so .idea folder is redundant.

Official docs: https://clang.llvm.org/extra/clang-tidy/checks/readability-identifier-naming.html
Example config: https://github.com/YACLib/YACLib/blob/main/.clang-tidy

Add clang-format to CI

Example: https://github.com/YACLib/YACLib/blob/main/.github/workflows/clang-format.yml