Использование std::enable_if во избежание неоднозначной перегрузки шаблонных бинарных операторов
Я хочу использовать std::enable_if, чтобы избежать неоднозначной перегрузки operator*(T,U) (или переопределений) между MyClass*otherT vs otherT*MyClass vs MyClassT*MyClassT.
Допустим, объявление MyClass:
template <typename T> class MyClassT { ... };
Тогда в глобальном масштабе:
template <typename T, typename U>
MyClassT<T> operator*(const MyClassT<T>& t, const MyClassT<U>& u)
{
//...
}
template <typename T, typename U, std::enable_if_t<!std::is_same_v<MyClassT<T>, U>,bool> = true >
MyClassT<T> operator*(const MyClassT<T>& t, const U& u)
{
//...
}
template <typename T, typename U, std::enable_if_t<!std::is_same_v<MyClassT<U>, T>,bool> = true >
MyClassT<U> operator*(const T& t, const MyClassT<U>& u)
{
//...
}
Но этот код все еще не может найти для него перегруженный оператор:
MyClassT<double> a;
double b;
MyClassT<double> c = a * b;
Мне нужна помощь, что случилось?
... недействителен в С++. Публикуйте только реальный код. Я видел, как люди (спрашивающие) меняли свой вопрос после публикации ответа, говоря, что это всего лишь пример, а не настоящий код. Поэтому всегда публикуйте реальный код. Это редактирование делает недействительными уже опубликованные ответы.
@user12002570 user12002570 это всего лишь пример фрагмента кода, и тело функции не имеет отношения к вопросу.
@wohlstad второй должен содержать T=double, а U=doubleMyClassT<double> не то же самое, что `double` , поэтому объявление будет действительным (обратите внимание !std::is_same_v
@uray Вам вообще не нужно использовать Enable_if. Смотрите мой ответ ниже.
Добавьте больше примеров к своему вопросу. Кажется, вы меняете требования к вопросу после того, как уже опубликованы два ответа.
на минутку, я вернусь к этому, ответ ниже - работа над тестом, но мой случай (с полным кодом) не работает, я проверю, есть ли что-то, что я пропустил в упрощенном коде, что не представляет вопрос
окей, ребята, извините, кажется, у меня проблема с AnotherMyClassT<T>, которая также перегружает оператор* между AnotherMyClassT<T> и U, поэтому каким-то образом между MyClassT и AnotherMyClassT возникает множественная/конфликтующая перегрузка.
@uray, ты прав насчет второй перегрузки. Это означает, что ваш опубликованный код на самом деле не имеет проблем (демо в комментарии под принятым ответом показывает, что он компилируется)
@uray Возможно, вы захотите отредактировать свой вопрос, сказав, что хотите улучшить свой вопрос, сделав его более читабельным, поскольку опубликованный вами код уже работает.
Ответы 1
Здесь не нужно использовать enable_if и аргумент по умолчанию, как показано ниже.
template <typename T, typename U >
MyClassT<T> operator*(const MyClassT<T>& t, const U& u)
{
//...
return {};
}
template <typename T, typename U >
MyClassT<U> operator*(const T& t, const MyClassT<U>& u)
{
//...
return {};
}
MyClassT<double> a;
double b;
MyClassT<double> c = a * b; //works now
MyClassT<double> k = b * a; //works
попробуйте с int b
@uray, вот почему мы просим минимально воспроизводимый пример вы должны показать весь код, с которым вы хотите работать, иначе люди будут делать предположения
@user12002570 user12002570 после комментариев под вопросом: можете ли вы объяснить, почему вторая перегрузка (с T=double и U=double) не соответствует случаю c = a * b в коде ОП? (несмотря на использование !std::is_same_v<MyClassT<T>, U>).
@wohlstad На самом деле это работает. Смотрите демо
Ага, понятно. Значит, весь вопрос на самом деле был неправильным, не так ли? (Я имею в виду, что исходный код действительно работал)
@wohlstad Ага, пропустили написать bool. Но все же сфины им здесь не нужны.
;@wohlstad Да, изначально он не компилировался.
Всегда публикуйте полную ошибку вместе с вопросом с минимально воспроизводимым примером