Перегрузка и неявное преобразование оператора C++

Question

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

class CFixed 
{ 
    CFixed(int ); 
    CFixed(float); 
}; 

CFixed operator* (const CFixed& a, const CFixed& b) 
{ ... } 

Все работает. Я могу написать 3 * CFixed (0) и CFixed (3) * 10.0f. Но теперь я понимаю, я могу реализовать оператор * с целочисленным операндом гораздо более эффективным. Поэтому я перегружать:

CFixed operator* (const CFixed& a, int b) 
{ ... } 
CFixed operator* (int a, const CFixed& b) 
{ ... } 

Он по-прежнему работает, но теперь CFixed (0) * 10.0f вызовы перегруженной версии, преобразования с плавающей точкой в ​​междунар (и я ожидал, что это конвертировать поплавок CFixed). Конечно, я могу перегрузить также и поплавковые версии, но для меня это комбинаторный взрыв кода. Есть ли способ обхода (или я неправильно проектирую свой класс)? Как я могу сказать компилятору вызывать перегруженную версию оператора * ТОЛЬКО с ints?

Answer 1

Предполагая, что вы хотите специализированную версию, чтобы быть выбраны для любого интегрального типа (а не только INT, в частности, одна вещь, которую вы могли бы сделать, это обеспечить, что в качестве функции шаблона и использовать Boost.EnableIf для удаления эти перегрузки из имеющегося набора перегрузки, если операнд не является целочисленным типом.

#include <cstdio> 
#include <boost/utility/enable_if.hpp> 
#include <boost/type_traits/is_integral.hpp> 

class CFixed 
{ 
public: 
    CFixed(int ) {} 
    CFixed(float) {} 
}; 

CFixed operator* (const CFixed& a, const CFixed& ) 
{ puts("General CFixed * CFixed"); return a; } 

template <class T> 
typename boost::enable_if<boost::is_integral<T>, CFixed>::type operator* (const CFixed& a, T ) 
{ puts("CFixed * [integer type]"); return a; } 

template <class T> 
typename boost::enable_if<boost::is_integral<T>, CFixed>::type operator* (T , const CFixed& b) 
{ puts("[integer type] * CFixed"); return b; } 


int main() 
{ 
    CFixed(0) * 10.0f; 
    5 * CFixed(20.4f); 
    3.2f * CFixed(10); 
    CFixed(1) * 100u; 
} 

Естественно, что вы могли бы ALS o использовать другое условие, чтобы сделать эти перегрузки доступными, только если T = int: typename boost::enable_if<boost::is_same<T, int>, CFixed>::type ...

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

Answer 2

Как насчет преобразования explicit?

Answer 3

Если у вас есть конструкторы, которые могут быть вызваны только одним аргументом, вы фактически создали неявный оператор преобразования. В вашем примере, где требуется CFixed, могут быть переданы как int, так и float. Это, конечно, опасно, потому что компилятор может без проблем генерировать код, вызывающий неправильную функцию, вместо того, чтобы лаять на вас, когда вы забыли включить объявление некоторой функции.

Поэтому хорошее эмпирическое правило гласит, что всякий раз, когда вы пишете конструкторы, которые могут быть вызваны только одним аргументом (обратите внимание, что этот foo(int i, bool b = false) может быть вызван одним аргументом, даже если он принимает два аргумента), вы должны сделать этот конструктор explicit, если вы действительно не хотите, чтобы неявное преобразование было введено. explicit конструкторы не используются компилятором для неявных преобразований.

Вы должны изменить свой класс на это:

class CFixed 
{ 
    explicit CFixed(int ); 
    explicit CFixed(float); 
}; 

Я обнаружил, что существует очень мало исключений из этого правила. (std::string::string(const char*) является довольно известным один.)

Edit: Мне очень жаль, что я пропустил пункт о не позволяет неявное преобразование из int в float.

Единственный способ, который я вижу для предотвращения этого, - предоставить операторы для float.

Answer 4

Согласен с sbi, вы должны определенно сделать ваши однопараметрические конструкторы явными.

Вы можете избежать взрыва в операторе <> функции вы пишете с шаблонами, однако:

template <class T> 
CFixed operator* (const CFixed& a, T b) 
{ ... } 

template <class T> 
CFixed operator* (T a, const CFixed& b) 
{ ... } 

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

Answer 5

Необходимо также перезагрузить float. Преобразование от int к указанному пользователем типу (CFixed) имеет более низкий приоритет, чем встроенное преобразование с плавающим интегралом в float.Поэтому компилятор всегда будет выбирать функцию с int, если вы не добавите функцию с float.

Подробнее см. Раздел 13.3 стандарта C++ 03. Почувствуй боль.

Кажется, что я тоже потерял его. :-(UncleBens сообщает, что добавление float только не решает проблему, так как добавлена ​​версия с double. Но в любом случае добавление нескольких операторов, связанных со встроенными типами, утомительно, но не приводит к комбинаторному подталкивание.