Question

#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<char*> Float;

#endif // NUMBER_HPP

此模板类分别初始化为两种数据类型。一个是int类型，另一个是char指针类型。

   typedef Number<int> Integer1,Integer2;
   typedef Number<char*> Char1,Char2;
   Integer2.setValue(2) ;
   Char2.setValue("ABC");
   Integer1 = Interger2;//Case 1
   Char1 = Char2; // Case 2

案例1：不需要深层复制。

案例2：我们正在复制指针时必须进行深层复制。

但是因为两个类都使用赋值运算符的相同基本副本。我们怎样才能做到这一点？

请建议一个不包含C ++ 11的解决方案。

Answer 1

也许您只想重载operator=：

template <class T2>
Number<T>& operator=( const Number<T2*>& number )
{
    // Deep Copy
}

template <class T2>
Number<T>& operator=( const Number<T2>& number )
{
    // Shallow Copy
}

在所有其他情况下，您希望std::enable_if静态地决定使用哪个副本状态，具体取决于类型（很可能是指针类型，例如std::is_pointer<T2>::value）。这可以通过if constexpr（C ++ 17）非常简单地简化：

#include <type_traits>

template <class T2>
Number<T>& operator=( const Number<T2>& number )
{
    if constexpr( std::is_pointer_v<T2> ){
        // Deep Copy
    }
    else{
        // Shallow Copy
    }
    return *this;
}

希望这有帮助！

Answer 2

我认为这就是你要找的东西。您正在为T2分配T。这意味着我们需要使用Number<T2>，将值转换为T，然后分配给this和return *this。

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

  return *this;
}

在类模板中重载赋值运算符

2 个答案: