Вычисление длины строки C во время компиляции. Это действительно constexpr?

Я пытаюсь вычислить длину строкового литерала во время компиляции. Для этого я использую следующий код:

#include <cstdio>

int constexpr length(const char* str)
{
    return *str ? 1 + length(str + 1) : 0;
}

int main()
{
    printf("%d %d", length("abcd"), length("abcdefgh"));
}

Все работает как положено, программа выводит 4 и 8. Ассемблерный код, сгенерированный clang, показывает, что результаты вычисляются во время компиляции:

0x100000f5e:  leaq   0x35(%rip), %rdi          ; "%d %d"
0x100000f65:  movl   $0x4, %esi
0x100000f6a:  movl   $0x8, %edx
0x100000f6f:  xorl   %eax, %eax
0x100000f71:  callq  0x100000f7a               ; symbol stub for: printf

Мой вопрос: гарантировано ли стандартом, что lengthфункция будет оцениваться во время компиляции?

Если это правда, дверь для вычислений строковых литералов времени компиляции только что открылась для меня ... например, я могу вычислять хэши во время компиляции и многое другое ...

Не гарантируется, что постоянные выражения будут вычислены во время компиляции, у нас есть только ненормативная цитата из чернового стандартного раздела C ++ 5.19 Постоянные выражения, в котором говорится следующее:

[...]> [Примечание: постоянные выражения можно оценивать во время перевода. — конец примечания]

Вы можете присвоить результат constexprпеременной, чтобы убедиться, что он оценивается во время компиляции, мы можем видеть это из справочника Бьярна Страуструпа по C ++ 11, в котором говорится ( выделено мной ):

Помимо возможности оценивать выражения во время компиляции, мы хотим иметь возможность требовать вычисления выражений во время компиляции; constexpr перед определением переменной делает это (и подразумевает const):

Например:

constexpr int len1 = length("abcd") ;

Бьярн Страуструп кратко описывает, когда мы можем гарантировать оценку времени компиляции в этой записи блога isocpp, и говорит:

[...] Правильный ответ - как указано Хербом - заключается в том, что согласно стандарту функция constexpr может оцениваться во время компиляции или во время выполнения, если она не используется как постоянное выражение, и в этом случае она должна быть оценена при компиляции -время. Чтобы гарантировать оценку во время компиляции, мы должны либо использовать его там, где требуется постоянное выражение (например, как привязка массива или как метка case), либо использовать его для инициализации constexpr. Я надеюсь, что ни один уважающий себя компилятор не упустит возможность оптимизации сделать то, что я изначально сказал: «Функция constexpr оценивается во время компиляции, если все ее аргументы являются постоянными выражениями».

Таким образом, здесь выделяются два случая, когда его следует оценивать во время компиляции:

1. Используйте его там, где требуется постоянное выражение, это может быть где-нибудь в черновике стандарта, где используется фраза shall be ... converted constant expressionили shall be ... constant expression, например, привязка к массиву.
2. Используйте его для инициализации a, constexprкак я обрисовал выше.

Очень легко узнать, приводит ли вызов constexprфункции к основному константному выражению или просто оптимизируется:

Используйте его в контексте, где требуется постоянное выражение.

int main()
{
    constexpr int test_const = length("abcd");
    std::array<char,length("abcdefgh")> test_const2;
}

Просто обратите внимание, что современные компиляторы (например, gcc-4.x) работают strlenсо строковыми литералами во время компиляции, потому что они обычно определяются как встроенные функции . Без включенной оптимизации. Хотя результат не является постоянной времени компиляции.

Например:

printf("%zu\n", strlen("abc"));

Результаты в:

movl    $3, %esi    # strlen("abc")
movl    $.LC0, %edi # "%zu\n"
movl    $0, %eax
call    printf

Позвольте предложить другую функцию, которая вычисляет длину строки во время компиляции без рекурсии.

template< size_t N >
constexpr size_t length( char const (&)[N] )
{
  return N-1;
}

Взгляните на этот пример кода на ideone .

Нет гарантии, что constexprфункция оценивается во время компиляции, хотя любой разумный компилятор выполнит это при включенных соответствующих уровнях оптимизации. С другой стороны, параметры шаблона должны оцениваться во время компиляции.

Я использовал следующий трюк, чтобы принудительно выполнить оценку во время компиляции. К сожалению, он работает только с целыми значениями (т.е. не со значениями с плавающей запятой).

template<typename T, T V>
struct static_eval
{
  static constexpr T value = V;
};

Теперь, если вы напишете

if (static_eval<int, length("hello, world")>::value > 7) { ... }

вы можете быть уверены, что этот ifоператор является константой времени компиляции без дополнительных затрат времени выполнения.

Краткое объяснение из статьи Википедии об обобщенных постоянных выражениях :

Использование constexpr для функции накладывает некоторые ограничения на то, что эта функция может делать. Во-первых, функция должна иметь непустой возвращаемый тип. Во-вторых, тело функции не может объявлять переменные или определять новые типы. В-третьих, тело может содержать только объявления, пустые операторы и один оператор возврата. Должны существовать такие значения аргументов, чтобы после подстановки аргументов выражение в операторе return давало постоянное выражение.

Наличие constexprключевого слова перед определением функции указывает компилятору проверить, соблюдены ли эти ограничения. Если да, и функция вызывается с константой, возвращаемое значение гарантированно будет постоянным и, таким образом, может использоваться везде, где требуется постоянное выражение.