Question

我有一个与转换不同类有关的问题，如下面的代码脚本所示：

template<typename E>
class Coordinate 
{
public:
    E x_;
    E y_;
    Coordinate(E x, E y):x_(x),y_(y) {};
    Coordinate():x_(0),y_(0) {};
    ~Coordinate() {};
};

typedef vector<Coordinate<float> > Cordfloat;
typedef vector<Coordinate<double> > Corddouble;




int main()
{
    Corddouble myarray;
    Coordinate<float> value(1.2,1.3);
    // myarray.push_back(value);  // failed!!!
    // Option 1
    Coordinate<double> temp;
    temp.x_ = static_cast<double>(value.x_);
    temp.y_ = static_cast<double>(value.y_);
    myarray.push_back(temp);
    // Option 2
    // myarray.push_back(static_cast<Coordinate<double> >(value)); // failed!!!
    // Option 3
    // myarray.push_back(dynamic_cast<Coordinate<double> >(value)); // failed!!!

    return 0;
}

在上面的代码中，我尝试了三种方法来完成这项工作。只有第一种方法有效。我似乎无法直接使用static_cast和dynamic_cast进行转换。我想知道是否有其他方法来执行转换任务。

Answer 1

添加转换构造函数或转换运算符（您可能只需要其中一个）：

template<typename E>
class Coordinate 
{
public:
    E x_;
    E y_;
    Coordinate(E x, E y):x_(x),y_(y) {};
    Coordinate():x_(0),y_(0) {};
    ~Coordinate() {};

    template<typename T>
    /*explicit*/ Coordinate(Coordinate<T> const& o)
       :x_(static_cast<E>(o.x_))
       ,y_(static_cast<E>(o.y_))
    {
    }


    template<typename T> /*explicit*/ operator Coordinate<T>() {
        return Coordinate<T>(static_cast<T>(x_), static_cast<T>(y_));
    }

};

Answer 2

在Coordinate中创建一个构造函数，该构造函数隐含在另一个Coordinate中：

template< typename E > class Coordinate 
{
  public:
    template< typename F >
    Coordinate( Coordinate<F> const& coord ) 
        : x_(coord.x_), y_(coord.y_)
    {
    }

    // rest
}

或者在你的构造函数中

        : x_( static_cast<E>(coord.x_) ),
          y_( static_cast<E>(coord.y_) )

Answer 3

模板化构造函数和模板化赋值可以很好地完成这项工作：

template<typename E>
class Coordinate 
{
public:
    E x_;
    E y_;
    //...

    template<typename T>
    Coordinate(Coordinate<T> const & c ) 
    : x_(static_cast<E>(c.x_)), 
      y_(static_cast<E>(c.y_)) 
    {
    }

    template<typename T>
    Coordinate<E> & operator=(Coordinate<T> const & c ) 
    {
       x_ = static_cast<E>(c.x_);
       y_ = static_cast<E>(c.y_);
       return *this;

    }
};

Answer 4

如果一个对象是另一个类/结构的子类，或者存在从一个类到另一个定义的转换运算符或转换构造函数，则只能将对象从一个类/结构转换为另一个类/结构。（我将这里的内置类型放在一边，它们有明确定义的转换）。

您可以使用static_cast从类转换为其基类之一。要从基类转换为派生类，必须使用dynamic_cast（它在执行强制转换之前检查基类实际上是派生类对象。）

坐标＆LT;浮动＆GT;既不是Coordinate＆lt; double＆gt;的子类也不是超类。

因此，您唯一的解决方案是编写转换运算符或从Coordinate＆lt; float＆gt;转换构造函数。协调＆lt; double＆gt;。

如何在C ++中的不同类之间进行转换？

4 个答案: