modèle; opérateur (int)

Question

concernant mon struct Point déjà mentionné ici:
template class: ctor against function -> new C++ standard
est-il une chance de remplacer le Toint() fonction avec un casting-opérateur (int)?

namespace point { 

template < unsigned int dims, typename T > 
struct Point { 

    T X[ dims ]; 

//umm??? 
    template < typename U > 
    Point< dims, U > operator U() const { 
     Point< dims, U > ret; 
     std::copy(X, X + dims, ret.X); 
     return ret; 
    } 

//umm??? 
    Point< dims, int > operator int() const { 
     Point<dims, int> ret; 
     std::copy(X, X + dims, ret.X); 
     return ret; 
    } 

//OK 
    Point<dims, int> toint() { 
     Point<dims, int> ret; 
     std::copy(X, X + dims, ret.X); 
     return ret; 
    } 
}; //struct Point 

template < typename T > 
Point< 2, T > Create(T X0, T X1) { 
    Point< 2, T > ret; 
    ret.X[ 0 ] = X0; ret.X[ 1 ] = X1; 
    return ret; 
} 
}; //namespace point 

int main(void) { 
    using namespace point; 
    Point< 2, double > p2d = point::Create(12.3, 34.5); 
    Point< 2, int > p2i = (int)p2d; //äähhm??? 
    std::cout << p2d.str() << std::endl; 
    char c; std::cin >> c; 
    return 0; 
} 

Je pense que le problème est ici que C++ ne peut pas distinguer entre différents types de retour? Merci d'avance. concernant
Oops

Answer 1

La syntaxe correcte est

operator int() const { 
    ... 

Il n'y a pas besoin d'avoir ce type de retour supplémentaire lorsque vous surcharger l'opérateur coulé.

Et quand vous dites (int)x, le compilateur s'attend vraiment à obtenir un int, pas un Point<dims, int>. Probablement, vous voulez un constructeur à la place.

template <typename U> 
Point(const Point<dims, U>& other) { ... }