¿Cómo evito que un lanzamiento implícito doble -> int?

Question

Pregunta como arriba, más detalles debajo:

Tengo una clase Money para ocuparse de ... bueno, usted adivinó qué. Estoy muy estricta de no permitir Money y double para interactuar (*), por lo que el siguiente código es no posible:

Money m1(4.50); 
double d = 1.5; 
Money m2 = m1 * d; // <-- compiler error 

Ahora estoy pensando que permite la multiplicación de Money con int, como en "usted tiene 6 pedazos de pastel por $ 4.50 cada uno (así que ve y encuentra un pastel más barato en alguna parte) ".

class Money 
{ 
    Money(); 
    Money(const Money & other); 
    explicit Money(double d); 
    ... 
    Money & operator*=(int i); 
    ... 
} 
inline const Money operator*(const Money & m, int i) { return Money(m) *= i; } 
inline const Money operator*(int i, const Money & m) { return Money(m) *= i; } 

que funciona bien, pero ... por desgracia, C++ hace conversiones implícitas de double a int, tan de repente mi primer fragmento de código se compilará. No quiero eso. ¿Hay alguna manera de evitar moldes implícitos en esta situación?

Gracias! - Robin

(*) Motivo: Tengo mucho de la de código heredado que se encarga de todas las cosas Money -relacionado con double, y yo no quiero ese tipo confundido hasta que todo correr con Money.

Editar: Constructores agregados para Money.

Edit: Gracias, a todos, por sus respuestas. Casi todos fueron geniales y serviciales. El comentario de R. Martinho Fernandes "usted puede hacer inline const Money operator*(const Money & m, double d) = delete;" fue en realidad la respuesta (tan pronto como cambie a un compilador compatible con C++ 11). Kerrek SB dio una buena alternativa sin C++ 11, pero lo que terminé usando es en realidad el enfoque de "sobrecarga long" de Nicola Musatti. Es por eso que estoy marcando su respuesta como "la respuesta" (también porque todas las ideas útiles surgieron como comentarios a su respuesta). ¡Gracias otra véz!

Answer 1

Se podría añadir una declaración para una sobrecarga privada de su operador de asignación aumentada:

private: 
    Money & operator*=(double i); 

Answer 2

¿Qué tal una plantilla de más tiempo de compilación cheque rasgo:

#include <type_traits> 

// ... 

template <typename T> 
Money & operator*=(const T & n) 
{ 
    static_assert(std::is_integral<T>::value, "Error: can only multiply money by integral amounts!"); 
    // ... 
} 

Answer 3

Se puede crear un número pequeño tipo de soporte que tenía todas las propiedades que deseaba, luego use eso para interactuar con otros tipos, como Money.

Answer 4

puedo pensar en dos formas de proporcionar la siguiente:

• ya sea usando la plantilla y los cheques "concepto"
• o el uso de "prohibido" sobrecargas

---

El uso de sobrecargas es la C++ 11 solución. C++ 11 introduce la palabra clave delete especialmente para su caso!

Money& operator*=(int i); 
Money& operator*=(float f) = delete; 

Money operator*(Money m, int i) { return m*i; } 
Money operator*(Money m, float f) = delete; 

Money operator*(int i, Money m) { return m*i; } 
Money operator*(float f, Money m) = delete; 

La forma más antigua (C++ 03) para ir de eso era doble:

• en la clase, declarar el método private
• no definen el método y esperar a que el enlazador para quejarse

El segundo es una salvaguarda en el caso del método de clase, y la única forma en el caso del método libre. Es triste que sólo se ha detectado durante el enlace ... y la palabra clave delete es mucho más bonito;)

---

Utilizando la plantilla es otra solución. Puede usar std::enable_if o static_assert: uno eliminará la función del conjunto de sobrecarga (SFINAE) mientras que el otro hará que la creación de instancias falle (error de compilación).

Ejemplo:

// For enable_if 
template <typename T> 
std::enable_if<std::is_integral<T>::value, Money&> operator*=(T t); 

template <typename T> 
std::enable_if<std::is_integral<T>::value, Money> operator*(Money m, T t); 

template <typename T> 
std::enable_if<std::is_integral<T>::value, Money> operator*(T t, Money m); 

Los ejemplos de static_assert son más naturales (que al igual que una aserción regular, en realidad).

---

yo preferiría recomendar la sobrecarga + delete si lo tiene. Si no lo hace, entonces una alternativa al caso de la plantilla es probablemente la mejor solución, ya que es más fácil corregir los errores del compilador que los del enlazador.