template < typename T >
struct Position {
    T x;
    T y;

    Position() {}
    Position(T px, T py) { x = px; y = py; }

    operator Position<float>(Position<int> const &orig) {
        return ( Position<float>(float(orig.x), float(orig.y)) );
    }
};

Allerdings schmeißt mir gcc

error: ‘Position<T>::operator Position<float>(const Position<int>&)’ must take ‘void’

entgegen. Daraus kann ich leider keinen Sinn entnehmen, da wenn die Funktion "void" als Argument nehmen würde könnte ja nichts umgewandelt werden (oder miss interpretiere ich das gänzlich)?

class X
{
    int i;
public:
    operator int() { return i; }
};

Jetzt kannst du X x z.B. in int i = x verwenden. Ein Parameter wäre hier sehr seltsam.

Wenn du den Konvertierungsoperator nur bei Position<int> haben willst, musst du entweder eine Spezialisierung für int schreiben oder mit boost::enable_if o.ä. arbeiten.

#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>

template<typename T>
struct point2d
{
  T x, y;

  explicit point2d(T x = T(), T y = T()) : x(x), y(y) {}

  template<typename U>
  point2d(point<U> const& p,
    typename boost::enable_if< boost::is_convertible<U,T> >::type* =0)
  : x(p.x), y(p.y) {}
};

(ungetestet)

kk