Conversion de type de modèle

Question

Je crée un modèle de matrice. Il y a des opérateurs, des fonctions et tout fonctionne bien. Sauf quand j'essaie de convertir une matrice de type double en matrice de type int (ou vice versa). = l'opérateur ne peut pas être défini, il n'est donc pas possible de le remplacer par basic_Matrix2D et basic_Matrix2D external par classe. Je sais que je peux écrire dans class = opérateurs pour la conversion mais dans ce cas il y aura deux = opérateur avec les mêmes paramètres. Lors de l'utilisation de double comme paramètre de modèle, la conversion à partir de double sera la même que la conversion à partir du paramètre de modèle. définition de classe est suit, les codes sont accessibles à partir SourceForge

template <class _T> class basic_Matrix2D { 

} 

Il y a aussi un autre problème je me suis souvenu sur les modèles, la conversion des œuvres de pointeur de type de modèle lors de la conversion de type de modèle ne fonctionne pas. Cela pourrait être spécifique au compilateur. observer:

operator _T() { 
    return something; 
} 

operator _T*() { 
    return somethingelse; 
} 

Merci à l'avance,
Cem

Answer 1

Votre question est très claire, mais il ne ya rien de mal à faire l'opérateur = quelque chose comme ceci:

// incomplete, but you get the idea 
template<class U> 
basic_Matrix2D<T> & operator=(const basic_Matrix2D<U> &x) 
{ 
    rows = x.rows; 
    cols = x.cols; 
    data = new T[rows * cols]; 
    for (size_t i = 0; i < rows * cols; ++i) 
     data[i] = x.data[i]; 
} 

Cela vous permettra affecter à partir de n'importe quelle matrice où l'expression T t; t = U(); est bien formée. Et si vous ne le pouvez pas, il échouera à compiler. Vous pouvez également inclure un opérateur d'affectation simple basic_Matrix2D<T> & operator=(const basic_Matrix2D<T> &); - peut-être que vous pouvez obtenir une efficacité supplémentaire ou quelque chose de différent.

Answer 2

Je pense qu'il ne serait pas rare de fournir un « constructeur de conversion »:

template <class U> 
Matrix2D<T>(const Matrix2D<U>&) 

Cela devrait automatiquement faire fonctionner le tout, par exemple

Matrix2D<double> a; 
Matrix2D<int> b; 
//implicitly uses the conversion constructor to create a temporary Matrix2D<double> from b 
a += b; 

Bien que si faire l'objet temporaire serait être trop cher, vous pouvez définir tous les opérateurs de sorte que les opérandes peuvent être différents types de matrices.

Les opérateurs de conversion sont cependant une impasse. Ils viennent boueux l'eau.

P.S J'ai également regardé les références de votre projet. Quel est le but de réinventer une liste chaînée, en particulier si son interface est complètement non compatible avec SC++ L? (Même une ancienne bibliothèque comme wxWidgets a fourni une alternative et préférée interface STL compatible pour leur wxString.)

---

Edit: En ce qui concerne votre problème de l'opérateur de conversion, le compilateur ne pas compiler avec?

template <class T> 
struct X 
{ 
    int n; 

    operator T() { return n; } 
    operator T*() { return &n; } 
}; 

int main() 
{ 
    X<int> x = {42}; 
    int a = x; 
    int* b = x; 
} 

Notez que cela pourrait être plutôt considéré comme un abus de la surcharge des opérateurs qui ne certainement pas faire votre propre code.