В принципе, я хотел бы использовать тип float16. Но этот вопрос заключается не в деталях, как это сделать, а в том, как настроить вещи так, чтобы мой новый тип float16 вел себя правильно с помощью float, double и всех целых типов.
Я бы хотел, чтобы мой тип float16 преобразовывался аналогично, чтобы плавать или удваивать. Например, он должен неявно использовать оба этих типа. Он также должен иметь std:: common_type (http://en.cppreference.com/w/cpp/types/common_type), который ведет себя аналогично для него, поскольку он std:: common_types ведет себя для других типов float. Это означает, что std::common_type<my_float16, float>::type = float, std::common_type<my_float16, double>::type = double и std::common_type<my_float16, T>::type = my_float16, где T - любой целочисленный тип.
Какие конструкторы и операторы литья нужно написать, чтобы сделать эту работу? Любая помощь будет оценена!
Мой другой недавний вопрос может быть связан.
EDIT: Хорошо, я построил минимальный пример, подобный Антону.
struct float16 {
explicit operator int() {
return 0;
}
operator float() {
return 0.0f;
}
};
Это имеет правильный общий тип для float и float16, но общий тип для int и float16 по-прежнему int. Я этого не понимаю.
Я собираюсь дать свой собственный ответ на этот вопрос.
Теперь я согласен с 6502, и я не думаю, что это возможно в простой форме. Единственный способ, которым я нашел это, - обеспечить перегрузку оператора для каждой возможной комбинации типов. Это можно сделать немного лучше с помощью шаблонов (и операторы Boost, http://www.boost.org/doc/libs/1_59_0/libs/utility/operators.htm, это хороший пример), но это все еще хороший объем работы и шаблонный код.
Я не думаю, что вы можете получить это точно, потому что основной язык С++ рассматривает изначально определенное преобразование (например, char to int) по-разному от пользовательского преобразования (даже если они неявные).
Например, после
struct float16 { float16(int) {} }; // cast int->float16 is implicit
struct Foo { Foo(const double&){} }; // constructor accepts a double&
struct Bar { Bar(const float16&){} }; // constructor accepts a float16&
void foo(const Foo&) {}
void bar(const Bar&) {}
вызов foo(3) действителен, поскольку целое число 3 может быть неявно преобразовано в double и foo принимает экземпляр foo, который может быть неявным образом создан из a double определяемым пользователем преобразование (конструктор foo, который не является explicit).
Однако bar(3) имеет значение не, потому что для такого вызова потребуются ДВА неявных пользовательских преобразований (int → float16 и float16 → Bar), и это не так допускается.
Если вы реализуете его как тип struct/class, предоставьте перегрузки всех соответствующих операторов и конструкторов. Просмотрите рекомендации, необходимые для класса, если он поддерживает преобразование как в другие, так и с других типов.
Если вы хотите, чтобы ваш класс хорошо играл со стандартными шаблонами, такими как std::common_type и std::numeric_limits, вам необходимо предоставить соответствующую специализацию этих шаблонов. Вероятно, лучше всего ознакомиться с фактическими стандартами для описания требований таких специализаций, но, вероятно, есть некоторые учебные материалы (я видел хороший вводный материал для специализации std::numeric_limits, но не для std::common_type).
Всегда будут некоторые ограничения на то, как ваш тип вписывается со встроенными стандартными типами (int, float и т.д.), если вы не используете типы, специфичные для компилятора.