Почему std :: any_cast не поддерживает неявное преобразование?

std::any_cast указан в терминах typeid. Процитирую cppreference по этому поводу:

Throws std::bad_any_cast if the typeid of the requested ValueType does not match that of the contents of operand.

Поскольку typeid не позволяет реализации «выяснить», возможно ли неявное преобразование, то (насколько мне известно) any_cast также не может знать, что это возможно.

Другими словами, стирание типов, предоставляемое std::any, полагается на информацию, доступную только во время выполнения. И эта информация не так богата, как информация, имеющаяся у компилятора для вычисления преобразований. Это стоимость стирания типа в C++ 17.

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

Есть языки, которые могут это сделать; каждый двоичный файл поставляется с байт-кодом IR (или исходным кодом) и интерпретатором / компилятором. Эти языки, как правило, в 2 раза или более медленнее, чем C++, в большинстве задач и имеют значительно больший объем памяти. Возможно, эти функции можно получить без такой стоимости, но ни у кого нет такого языка, о котором я знаю.

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

std::anyимеет должен быть реализован со стиранием типа. Это потому, что он может хранить тип любой и не может быть шаблоном. На данный момент в C++ нет других функций для достижения этой цели.

Это означает, что std::any сохранит указатель со стиранием типа, void* и std::any_cast преобразуют этот указатель в указанный тип и все. Он просто выполняет проверку работоспособности с помощью typeid, прежде чем проверить, является ли тип, к которому вы его применяете, тем, который хранится в any.

При текущей реализации невозможно разрешить неявные преобразования. Подумайте об этом (пока игнорируйте проверку typeid).

std::any_cast<long>(a);

a хранит int, а не long. Как std::any должен это знать? Он может просто привести свой void* к указанному типу, разыменовать его и вернуть. Приведение указателя от одного типа к другому является строгим нарушением псевдонима и приводит к UB, так что это плохая идея.

std::any должен был бы сохранить фактический тип объекта, хранящегося в нем, что невозможно. Сейчас вы не можете хранить типы в C++. Он может поддерживать список типов вместе с соответствующими typeid и переключать их, чтобы получить текущий тип и выполнить неявное преобразование. Но нет способа сделать это для одиночного типа каждый, который вы собираетесь использовать. Типы, определяемые пользователем, в любом случае не будут работать, и вам придется полагаться на такие вещи, как макросы, чтобы «зарегистрировать» свой тип и сгенерировать соответствующий случай переключения для него ¹.

Может быть, примерно так:

template<typename T>
T any_cast(const any &Any) {
  const auto Typeid = Any.typeid();
  if (Typeid == typeid(int))
    return *static_cast<int *>(Any.ptr());
  else if (Typeid == typeid(long))
    return *static_cast<long *>(Any.ptr());
  // and so on. Add your macro magic here.

  // What should happen if a type is not registered?
}

Это хорошее решение? Нет, конечно. Переключение стоит дорого, и мантра C++ - «вы не платите за то, что не используете», так что нет, в настоящее время нет способа добиться этого. Подход также «хакерский» и очень хрупкий (что произойдет, если вы забудете зарегистрировать тип). Короче говоря, возможные выгоды от выполнения чего-то подобного вообще не стоят проблем.

is there a workaround to allow an implicit conversion (in case the exact type that std::any holds is unknown)?

Да, реализовать std::any (или аналогичный тип) и std::any_cast самостоятельно, используя упомянутый выше подход макросов ¹. Я не буду рекомендовать это. Если вы не знаете и не можете знать, какой тип хранится в std::any и вам нужно получить к нему доступ, у вас возможный недостаток в конструкции.

¹: На самом деле не знаю, возможно ли это, я не так хорош в использовании макросов (ab). Вы также можете жестко запрограммировать свои типы для своей пользовательской реализации или использовать для этого отдельный инструмент.

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

std::any("blabla");

будет работать, но будет хранить char const*, а не массив. Вы можете добавить такую ​​функцию в свой собственный настроенный any, но тогда вам нужно будет сохранить указатель на строковый литерал, выполнив:

any(&*"blabla");

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

Вы также можете расширить any для хранения и последующего вызова функторы со стиранием типа, например, но это также не поддерживается стандартом.

Этот вопрос поставлен неправильно; неявное преобразование в правильный тип в принципе возможно, но отключено. Это ограничение, вероятно, существует для поддержания определенного уровня безопасности или имитации явного приведения, необходимого (через указатель) в C-версии any (void*). (Пример реализации ниже показывает, что это возможно.)

При этом ваш целевой код по-прежнему не работает, потому что вам нужно знать точный тип перед преобразованием, но это может сработать в принципе:

any a = 10;  // holds an int now
long b = int(a); // possible but today's it should be: long b = any_cast<int>(a);

Чтобы показать, что неявные преобразования технически возможны (но могут не работать во время выполнения):

#include<boost/any.hpp>

struct myany : boost::any{
    using boost::any::any;
    template<class T> operator T() const{return boost::any_cast<T>(*this);}
};

int main(){

    boost::any ba = 10;
//  int bai = ba; // error, no implicit conversion

    myany ma = 10; // literal 10 is an int
    int mai = ma; // implicit conversion is possible, other target types will fail (with an exception)
    assert(mai == 10);

    ma = std::string{"hello"};
    std::string mas = ma;
    assert( mas == "hello" );
 }