Constexpr evaluation inside a constructor

Question

I develop my own string class that has both small string optimization and has an internal flag to know if the string is Ascii, UTF8, WTF8 or a byte string. The constructor

String(const char* );

can be used to construct either an Ascii string or an UTF8 string. It should only be used with literals such as:

const String last_name = "Fayard"
const String first_name = "François"

The constructor needs to compute both the length of the string and check if it is Ascii or UTF8. Therefore, I wrote those functions so they can be evaluated at compile time.

inline constexpr il::int_t size(const char* s) {
  return (*s == '\0') ? 0 : (size(s + 1) + 1);
}

inline constexpr bool isAscii(const char* s) {
  return (*s == '\0')
         ? true
         : (((static_cast<unsigned char>(*s) & 0x80_uchar) ==
             0x00_uchar) && isAscii(s + 1));
}

The constructor is written like this and is available in the headers so he can be inlined.

String(const char* data) {
  const int n = size(data);
  const bool ascii = isAscii(data);

  if (n <= max_small_string) {
    ...
  } else {
    data_ = malloc();
    ...
  }
}

But I can't manage to get the functions size and isAscii run be evaluated at compile time (tried and check the assembly with gcc 4.8.5, clang 4.0.1, icpc 17.0.4). Is there a way to do that?

PS : The solution needs to be C++11 only and compile with gcc 4.8.5 and Visual Studio 2015.

Answer 1

You can use enable_if to constrain your constructor not to take more than 22 characters:

template<size_t N, typename std::enable_if<(N <= 22), int>::type = 0> 
constexpr String(const char(&string_literal)[N]) { /*...*/ }

Answer 2

argument of function are not constexpr, so you cannot propagate the string literal.

One way is to turn literal string into char sequence:

template<typename C, C...cs> struct Chars
{
    using str_type = C[1 + sizeof...(cs)];
    static constexpr C str[1 + sizeof...(cs)] = {cs..., 0};

    constexpr operator const str_type&() const { return str; }
};

template<typename C, C...cs> constexpr C Chars<C, cs...>::str[1 + sizeof...(cs)];

// Requires GNU-extension
template <typename C, C...cs>
constexpr Chars<C, cs...> operator""_cs() { return {}; }

Without gnu extension, you have to use some MACRO to transform literal into char sequence, as I do there.

Then you have all value information from types:

template <typename C, C ... Cs>
constexpr il::int_t size(Chars<C, Cs...>) {
  return sizeof...(Cs);
}

template <typename C, C ... Cs>
constexpr bool isAscii(Chars<C, Cs...>) {
    // C++17 folding expression
    return ((static_cast<unsigned char>(Cs) & 0x80_uchar) == 0x00_uchar && ...);
}

or for C++11:

template <typename C>
constexpr bool isAscii(Chars<C>) { return true; }

template <typename C, C head, C ... Cs>
constexpr bool isAscii(Chars<C, Cs...>) {
    // C++17 folding expression
    return ((static_cast<unsigned char>(Head) & 0x80_uchar) == 0x00_uchar
           && isAscii(Chars<C, Cs...>{});
}

Answer 3

This is basically @Öö Tiib's ideea, but expanded to show it works in gcc 4.8.5 as you said you require:

struct String
{
  static const int max_small_string = 10;
  int size_;
  char* data_;

  template <int N,
      typename std::enable_if<(N <= String::max_small_string), void*>::type = nullptr>
  constexpr String(const char (&str)[N])
    : size_{size(str)},
      data_{}
  {
  }

  template <int N,
    typename std::enable_if<(N > String::max_small_string), void*>::type = nullptr>
  String(const char (&str)[N])
    : size_{size(str)},
       data_{static_cast<char*>(malloc(size_))}
  {
  }
};


auto foo() -> void
{
  constexpr String ss = String{"asd"}; // OK, constexpr

  String hs =  String{"a sdjwq niornyuqe rniehr iwhtR Trtj rjtsd asde"};
}

You cannot have a constexpr containing malloc, there is no way around it and it looks it will never be. I read about some discussion about introducing a constexpr_vector into the standard, but allowing random memory access in constexpr context will be extremely tricky because constexpr needs to detect and fail on every possible UB and so it most likely won't be supported in the foreseeable future.

But you can have a constexpr small string constructor as I've shown you. Check it on godbolt with gcc 4.8.5

---

You said you want to initialize a stack variable. By that I think you mean an automatic storage one. Yes it can be done in C++11:

template <int... Is> struct Seq{};

template <int I, int Max, int... Is>
struct Make_seq_impl
{
    using Type = typename Make_seq_impl<I + 1, Max, Is..., I>::Type;
};

template <int Max, int... Is>
struct Make_seq_impl<Max, Max, Is...>
{
    using Type = Seq<Is...>;
};

template <int N>
using Make_seq = typename Make_seq_impl<0, N>::Type;

struct X
{
    static const int max_size_ = 10;
    char data_[max_size_];

    template <int N, int... Is>
    constexpr X(const char (&str)[N], Seq<Is...>)
        : data_ {(Is < N ? str[Is] : '\0')...}
    {
    }

    template <int N>
    constexpr X(const char (&str)[N])
        : X(str, Make_seq<max_size_>{})
    {
    }
};

auto test() -> void
{
    constexpr X x{"Asd"};

    static_assert(x.data_[0] == 'A', "");
    static_assert(x.data_[1] == 's', "");
    static_assert(x.data_[2] == 'd', "");
    static_assert(x.data_[3] == '\0', "");
}

I left it to you to combine the 2 methods.