La sobrecarga de operador de asignación en una plantilla de clase que puede convertir a otro tipo de plantilla

#ifndef NUMBER_HPP
#define NUMBER_HPP

template <class T>
class Number
{
public:
  Number( T value ) : m_value( value )
  {
  }

  T value() const
  {
    return m_value;
  }

  void setValue( T value )
  {
    m_value = value;
  }

  Number<T>& operator=( T value )
  {
    m_value = value;
  }

  // template <class T2>
  // Number<T2>& operator=( const Number<T>& number )
  // {
  //   m_value = number.value();

  //   return *this;
  // }

private:
  T m_value;
};

typedef Number<int> Integer;
typedef Number<float> Float;
typedef Number<double> Double;

#endif //NUMBER_HPP

Comentó el operador de asignación sobrecarga es mi intento de hacer lo que quiero, pensé que podría proporcionar una mejor descripción de la de arriba el fragmento de código.

Quiero ser capaz de hacer lo siguiente:

Float a(10);
Integer b(20);

a = b;

Donde a entonces se puede lanzar a un int y dado el valor de b, pero todavía puede ser una instancia de la clase Number.

Es posible? Puede usted ayudarme a salir de aquí?

Gracias de antemano.

Lo que está mal con el operador de asignación por defecto, combinado con la conversión implícita proporcionados por el constructor? Que va a hacer exactamente lo que los operadores están tratando de hacer, sin tener que escribir ningún código.
Ha sido un tiempo desde que hice en C++, pero también puede anular la cast/operador de conversión.

InformationsquelleAutor mkroman | 2011-11-29

2 Comentarios

7

Usted debe hacer esto:
```
template <class T2>
Number<T>& operator=( const Number<T2>& number )
{
    m_value = number.value();
    return *this;
}
```
Que es, el uso de T2 en el tipo de parámetro, no en el tipo de retorno!

Prefiero utilizar letra diferente para el parámetro de plantilla:
```
template <class U>
Number<T>& operator=( const Number<U>& number )
{
    m_value = number.m_value; //I would also directly access the member variable!
    return *this;
}
```
Creo, es mejor utilizar explícita emitidos, si desea utilizar el tipo de clase como argumento de plantilla y cuyo constructor ha sido declarado explicit:
```
 m_value = static_cast<T>(number.m_value); 
```
Por cierto, el otro operator= debe ser implementada como:
```
Number<T>& operator=(T const & value ) //accept by const reference
{
    m_value = value;
    return *this; //you've to return!
}
```
- Sí, muchas gracias. @SethCarnegie le preguntó qué pasaba cuando yo sin comentar el código, al mismo tiempo que yo sin comentar me di cuenta de la forma en que estaba comprobando el resultado fue con printf() el uso de %d en lugar de %f de la carroza. Tonto. Gracias a los dos.
InformationsquelleAutor Nawaz

Usted tiene algunos de los Ts en el lugar equivocado. Debe ser

template <class T2>
Number<T>& operator=( const Number<T2>& number )
{
    m_value = number.value();
    return *this;
}

Esto le permitirá hacer

Integer a(4);
Float b(6.2f);

a = b;

cout << a.value() << endl;

y se va a imprimir 6, un comportamiento similar a la de la int y float tipos que están imitando.

InformationsquelleAutor Seth Carnegie

2 Comentarios

Dejar respuesta Cancelar respuesta