Поддерживается ли неявное преобразование из unique_ptr в необработанный указатель?

Вот в чем дело. Нет неявного преобразования в базовый указатель, вам нужно вызвать определенную функцию-член get (это тема в стандартной библиотеке, подумайте std::string::c_str).

Но это хорошо! Неявное преобразование указателя может нарушить гарантии unique_ptr. Рассмотрим следующее:

std::unique_ptr<int> p1(new int);
std::unique_ptr<int> p2(p1);

В приведенном выше коде компилятор может попытаться передать указатель p1s в p2! (Этого не произойдет, поскольку этот вызов все равно будет неоднозначным, но предположим, что это не так). Они оба назовут delete!

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

Теперь давайте рассмотрим ваш код:

(*test)[0] = 5;

Он вызывает unique_ptr::operator*, который возвращает int&¹. Затем вы пытаетесь использовать на нем оператор нижнего индекса. Это ваша ошибка.
Если у вас есть std::unique_ptr<int[]>, просто используйте перегрузку operator[], которую предоставляет дескриптор:

test[0] = 5;

¹ Как указал Дэвид Скарлетт, он даже не должен компилироваться. Версия массива не должна иметь этого оператора.

Как указывает StoryTeller, неявные преобразования испортили бы шоу, но я хотел бы предложить другой способ думать об этом:

Интеллектуальные указатели, такие как unique_ptr и shared_ptr, пытаются скрыть базовый необработанный указатель, потому что они пытаются поддерживать над ним определенную семантику владения. Если бы вы могли свободно получить этот указатель и передавать его, вы могли бы легко нарушить эту семантику. Они по-прежнему предоставляют способ доступа к нему (get), так как они не могли бы полностью остановить вас, даже если бы захотели (в конце концов, вы можете просто следовать умному указателю и получить адрес указателя). Но они все еще хотят поставить барьер, чтобы убедиться, что вы не получите к нему доступ случайно.

Однако не все потеряно! Вы все еще можете получить это синтаксическое удобство, определив новый тип интеллектуального указателя с очень слабой семантикой, так что его можно будет безопасно неявно построить из большинства других интеллектуальных указателей. Рассмотреть возможность:

// ipiwdostbtetci_ptr stands for : 
// I promise I wont delete or store this beyond the expression that created it ptr
template<class T>
struct ipiwdostbtetci_ptr {
    T * _ptr;
    T & operator*() {return *_ptr;}
    T * operator->(){return _ptr;}
    ipiwdostbtetci_ptr(T * raw): _ptr{raw} {}
    ipiwdostbtetci_ptr(const std::unique_ptr<T> & unq): _ptr{unq.get()} {}
    ipiwdostbtetci_ptr(const std::shared_ptr<T> & shr): _ptr{shr.get()} {}
};

Итак, в чем смысл этой сатирически названной умной указки? Это просто своего рода указатель, которому устно дается контракт о том, что пользователь никогда не будет оставлять его или его копию в живых за пределами выражения, которое его создало, и пользователь также никогда не будет пытаться его удалить. С этими ограничениями, за которыми следует пользователь (без проверки компилятором), совершенно безопасно неявно преобразовывать многие интеллектуальные указатели, а также любые необработанные указатели.

Теперь вы можете реализовать функции, которые ожидают ipiwdostbtetci_ptr (при условии, что они будут соблюдать семантику), и удобно вызывать их:

void f(ipiwdostbtetci_ptr<MyClass>);
...
std::unique_ptr<MyClass> p = ...
f(p);