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() {};
};

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_castanddynamic_cast进行转换。我想知道是否还有其他方法可以执行转换任务。

4

4 回答 4

4

添加转换构造函数或转换运算符（您可能只需要两者之一）：

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_));
    }

};
于 2012-10-24T10:34:48.570 回答
3

在 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_) )
于 2012-10-24T10:35:38.570 回答
2

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

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;

    }
};
于 2012-10-24T10:34:48.630 回答
1

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

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

Coordinate<float> 既不是 Coordinate<double> 的子类也不是超类。

因此，您唯一的解决方案是编写一个转换运算符或将构造函数从 Coordinate<float> 转换为 Coordinate<double>。

于 2012-10-24T10:40:25.023 回答