Какова продолжительность хранения и время существования параметра шаблона, не являющегося типом, и как его можно использовать для вычислений во время компиляции?

В C++ Weekly — Ep 313 — Проблема constexpr, на решение которой мне потребовалось 5 лет!, Джейсон Тернер демонстрирует несколько методов времени компиляции, позволяющих создать std::string во время компиляции, а затем передать его std::string_view для использования во время выполнения.

Основная проблема заключается в том, что std::string использует new, созданное во время компиляции std::string должно использоваться в одном выражении, поскольку new должно иметь соответствующее delete внутри того же constant/compile-time context (извините за приблизительную формулировку).

Поскольку код довольно длинный, я поставил его в конце своего вопроса.

Для этого он сначала показывает, как данные из std::string можно скопировать в std::array, сохраняя их внутри функций consteval (на данный момент я не уверен, что этого нельзя достичь просто с помощью функции constexpr).

Чего я вообще не понимаю, так это того, как он «продлевает» время жизни std::array за пределы непосредственного вызова функций с использованием параметра шаблона , не являющегося типом (NTTP), примерно на 19 минут.

Мое (вероятно, неправильное) понимание из стандарта заключается в том, что NTTP связан с template parameter object со статической длительностью хранения:

Выражение id, именующее нетиповой параметр шаблона типа класса T, обозначает статический объект продолжительности хранения типа const T, известный как объект параметра шаблона, который эквивалентен аргументу шаблона ([temp.type]) объекту соответствующий аргумент шаблона после его преобразования в тип параметра шаблона ([temp.arg.nontype]). Никакие два объекта параметров шаблона не являются эквивалентными аргументам шаблона.

Тем не менее, я попытался поиграться с гораздо более простым (и надуманным) примером:

template <auto Value>
consteval const auto& make_static() {
    return Value;
}

int main() {
    [[maybe_unused]] const auto& i = make_static<2>();             // (1)
    [[maybe_unused]] static const auto& j = make_static<2>();      // (2)
    [[maybe_unused]] static constexpr auto& k = make_static<2>();  // (3)
    [[maybe_unused]] constinit static auto& l = make_static<2>();  // (4)
    return i;
}

Прямой эфир

Ни одна из многих попыток не увенчалась успехом, как видно из предоставленной связанной демо-версии. Разные составители ставят мне разные диагнозы.

Обычно make_static<2>() не считается постоянным выражением и возвращает ссылку на временный объект (что, насколько я понимаю, превосходит цель Джейсона Тернера).
Примечание: GCC 13.2 (27 июля 2023 г.) даже жалуется на разыменование nullptr, но магистральная версия кажется более совместимой с MSVC и Clang.

Что не так с моим примером и как в этом свете работает вариант использования Джейсона Тернера?

#include <algorithm>
#include <array>
#include <cstddef>
#include <format>
#include <iostream>
#include <string>

// Some algorithm to generate a fancy std::string, possibly at compile-time
constexpr std::string make_string(std::string_view base,
                                  const std::size_t repeat) {
    std::string retval;
    for (std::size_t count = 0; count < repeat; ++count) {
        retval += base;
    }
    return retval;
}

// Use only at compile-time: it must be large enough to hold
// a copy of the string data in "constant evaluated context"
// NB: It is probably wrong wording above
struct oversized_array {
    //static constexpr std::size_t VeryLargeSize = 10 * 1024 * 1024;  // Jason
    //turner example
    static constexpr std::size_t VeryLargeSize =
        1000;  // Jason Turner value was too large for MSVC on Compiler Explorer
    std::array<char, VeryLargeSize> data{};
    std::size_t size;  // Actually the used size, VeryLargeSize max.
};

// Copy a string containt into an array "large enough".
// It is a helper for to_right_sized_array below
constexpr auto to_oversized_array(const std::string &str) {
    oversized_array result;
    std::copy(str.begin(), str.end(), result.data.begin());
    result.size = str.size();
    return result;
}

// Copy a string containt into an array of the same size.
// The callable is a lambda that is wrapping make_string.
// KO FOR CLANG
template <typename Callable>
consteval auto to_right_sized_array(
    Callable callable) {  // Jason Turner version
    // constexpr auto to_right_sized_array(Callable callable) { // It seems to be
    // enough
    constexpr auto oversized = to_oversized_array(callable());
    std::array<char, oversized.size> result;
    std::copy(oversized.data.begin(),
              std::next(oversized.data.begin(), oversized.size),
              result.begin());
    return result;
}

// Merely returns a reference to the NTTP 'Data'.
// THE CORE OF MY QUESTION IS HERE
template <auto Data>
consteval const auto &make_static() {
    return Data;
}

// Wrapping the array-converted string into a string_view
template <typename Callable>
consteval auto to_string_view(Callable callable) {
    // std::array as NTTP is C++20?
    constexpr auto &static_data = make_static<to_right_sized_array(callable)>();
    return std::string_view{static_data.begin(), static_data.size()};
}

int main() {
    constexpr auto make_data = []() {
        return make_string("Hello compile-time world,", 3);
    };
    constexpr static auto view = to_string_view(make_data);

    std::cout << std::format("{}: {}", view.size(), view);
}

Прямой эфир

Примечание: Эту версию принимает только GCC. Кажется, MSVC путают с std::string_view API (или, может быть, я допустил опечатку при копировании кода Джейсона Тернера). Кланг не согласен со всеми этими постоянными оценками. Это может быть связано с одним из моих предыдущих постов: GCC и Clang ведут себя по-разному в отношении постоянной оценки