Почему нет неявного преобразования из std::string_view в std::string?

Проблема в том, что std::string_view -> std::string создает копию базовой памяти с выделением кучи, тогда как неявный std::string -> std::string_view этого не делает. Если вы удосужились использовать std::string_view в первую очередь, то вы, очевидно, заботитесь о копиях, поэтому вы не хотите, чтобы это происходило неявно.

Рассмотрим этот пример:

void foo1(const std::string& x)
{
    foo2(x);
}
void foo2(std::string_view x)
{
    foo3(x);
}
void foo3(const std::string& x)
{
    // Use x...
}

Функция foo2 могла бы использовать параметр const std::string&, но использовала std::string_view, так что она более эффективна, если вы передаете строку, которая не является std::string; там никаких сюрпризов. Но это менее эффективно, чем если бы вы просто дали ему параметр const std::string&!

• Когда foo2 вызывается с аргументом std::string (например, foo1): Когда foo2 вызывает foo3, создается копия строки. Если бы у него был аргумент const std::string&, он мог бы использовать объект, который у него уже был.
• Когда foo2 вызывается с аргументом const char*: std::string копия должна быть сделана рано или поздно; с параметром const std::string& он создается раньше, но в целом в любом случае есть ровно одна копия.

Теперь представьте, что foo2 вызывает несколько функций, таких как foo3, или вызывает foo3 в цикле; он снова и снова создает один и тот же объект std::string. Вы бы хотели, чтобы компилятор уведомил вас об этом.

Потому что дорогие неявные преобразования нежелательны...

Вы указали только одно неявное преобразование из всего набора примеров: const char* -› std::string; и вы просите еще один. Во всех остальных функциях, помеченных 'OK', выделение памяти очевидно/явно:

• Назначения: когда вы назначаете что-либо объекту-владельцу с переменным размером хранилища, подразумевается, что может потребоваться выделение. (Если это не задание на перемещение, но неважно.)
• Приложение I: когда вы добавляете к объекту-владельцу переменный размер хранилища, становится еще более очевидным, что для размещения дополнительных данных потребуется выделение. (У него может быть достаточно зарезервированного места, но никто не гарантирует этого в отношении строк.)
• Конкатенации: во всех трех случаях память выделяется только для результата, а не для какого-либо промежуточного объекта. Выделение для результата, очевидно, необходимо, поскольку операнды конкатенации остаются нетронутыми (и в любом случае нельзя предполагать, что они содержат результат).

Неявные преобразования в целом имеют свои преимущества и недостатки. С++ на самом деле в основном скуп на них и наследует большинство неявных преобразований от C. Но - const char* в std::string является исключением. Как отмечает @ArthurTacca, он выделяет память. Основные рекомендации C++ гласят:

C.164: избегайте неявных операторов преобразования

Причина.
Неявные преобразования могут быть необходимы (например, double в int), но часто вызывают неожиданности (например, String в строку в стиле C).

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

PS - у std::string_view довольно много ошибок; см. это выступление Виктора Чиуры на CppCon 2018:

Достаточно string_view, чтобы повеситься

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

... явного конструктора достаточно.

действительно существует явный конструктор std::string из std::string_view. Используйте его, передав std::string{my_string_view} функции, принимающей строку.