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

上記のコードでは、仕事をするために 3 つの方法を試しています。最初の方法のみが機能します。static_castanddynamic_castを直接変換に使用できないようです。変換タスクを実行する他の方法があるかどうか疑問に思っていました。

4

4 に答える 4

4

変換コンストラクターまたは変換演算子を追加します (おそらく、2 つのうちの 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_));
    }

};
于 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 を使用して、クラスからその基底クラスの 1 つに変換できます。基本クラスから派生クラスに変換するには、dynamic_cast を使用する必要があります (キャストを進める前に、基本クラスが実際に派生クラス オブジェクトであることを確認します)。

Coordinate<float> は、Coordinate<double> のサブクラスでもスーパークラスでもありません。

したがって、唯一の解決策は、変換演算子または変換コンストラクターを Coordinate<float> から Coordinate<double> に記述することです。

于 2012-10-24T10:40:25.023 に答える