Newsgroup: it.comp.lang.c++
Titolo: Templates

Ciao a tutti!
Ho scritto una piccola classe per operare sui quaternioni, so che ce ne 
sono già di valide in giro, ma preferisco scrivere tutto da me anche 
perchè mi intriga molto la sfida e soprattutto perchè in questo modo 
adatto già il codice alle mie esigenze.
Ho già fatto l'overloading dei principali operatori (+ - * / =) e 
funziona tutto. Solo a questo punto pensavo di fare in modo che la 
classe sia utilizzabile sia con gli interi che con i decimali per cui mi 
chiedevo se fosse il caso di scomodare i templates.
Il problema principale è che io nella classe ho dichiarato delle 
variabili (Re,I,J,K) che sono rispettivamente la parte reale e le 3 
parti complesse, ma in questo modo devo dargli un tipo. Infatti 
attualmente tutto funziona con degli int.
Come fare per far si che Re I J e K possano essere immessi di qualsiasi tipo
typedef class Quaternion
{
public:
Quaternion(int re, int i, int j, int k);
~Quaternion();
Quaternion operator-() const;
Quaternion operator-(const Quaternion& B) const;
Quaternion operator+(const Quaternion& B) const;
Quaternion operator*(const Quaternion& B) const;
Quaternion operator/(const Quaternion& B) const;
const Quaternion & operator=(const Quaternion & B);
int Re;
int I;
int J;
int K;
}Q;
Ciao, Aspidus

 tipo
1. non capisco perchè usi un typedef li.
2. la tua domanda è veramente banale: ti posso anche rispondere, ma 
questo non vuole dire che tu non abbia disperato bisogno di un buon 
manuale. 
A riguardo consiglio il Lippman-Lajole.
Non è codice testato, è scritto a braccio, ma prova a vedere se ti fa 
comodo.
template<typename T>
class Quaternion{
public:
	Quaternion<T>(T re, T i, T j, T k);
	Quaternion<T>(const Quaternion<T>&);
	template<typename U>
	Quaternion<T>(const Quaternion<U>&);
	~Quaternion<T>();
	Quaternion<T> operator-() const;
	Quaternion<T> operator-(const Quaternion<T>& B) const;
	Quaternion<T> operator+(const Quaternion<T>& B) const;
	Quaternion<T> operator*(const Quaternion<T>& B) const;
	Quaternion<T> operator/(const Quaternion<T>& B) const;
	const Quaternion<T>& operator=(const Quaternion<T>& B);
T Re;
T I;
T J;
T K;
};
-- 
-rik0

Avevo già provato qualcosa di molto molto simile, ma in compilazione 
ricevevo (quando l'ho provato) e tutt'ora ricevo con il codice che hai 
postato tu degli errori dal linker.
Io credo sia dovuto al fatto che non ho ben capito (perchè mi è capitato 
raramente di dover usare templates) se ho implementato correttamente i 
metodi oppure no.
Il linker mi da una serie di questi errori:
[Linker error] undefined reference to `Quaternion<int>::Quaternion(int, 
int, int, int)'
nel main eseguo questo
Quaternion<int> q1(6,7,4,9);
Quaternion<int> q2(5,3,5,6);
Quaternion<int> q3=q1+q2;
Mentre i metodi li ho definiti così:
#include "Quaternion.h"
template<typename T> Quaternion<T>::Quaternion(T re, T i, T j, T k)
{
Re = re;
I = i;
J = j;
K = k;
}
template<typename T> Quaternion<T>::Quaternion(const Quaternion<T>& q)
{
Re=q.Re, I=q.I, J=q.J, K=q.K;
}
template<typename T> template<typename U> 
Quaternion<T>::Quaternion(const Quaternion<U>& q)
{
Re=q.Re, I=q.I, J=q.J, K=q.K;
}
template<typename T> Quaternion<T>::~Quaternion()
{
}
template<typename T> Quaternion<T> Quaternion<T>::operator-() const
{
return Quaternion(-Re, -I, -J, -K);
}
template<typename T> Quaternion<T> Quaternion<T>::operator-(const 
Quaternion& B) const
{
return Quaternion(Re-B.Re, I-B.I, J-B.J, K-B.K);
}
template<typename T> Quaternion<T> Quaternion<T>::operator+(const 
Quaternion& B) const
{
return Quaternion(Re+B.Re, I+B.I, J+B.J, K+B.K);
}
template<typename T> Quaternion<T> Quaternion<T>::operator*(const 
Quaternion& B) const
{
return Quaternion((Re*B.Re)-(I *B.I )-(J *B.J )-(K*B.K  ),
                   (Re*B.I )+(I *B.Re)+(J *B.K )-(K *B.J ),
                   (Re*B.J )-(I *B.K )+(J *B.Re)+(K *B.I ),
                   (Re*B.K )+(I *B.J )-(J *B.I )+(K *B.Re));
}
template<typename T> Quaternion<T> Quaternion<T>::operator/(const 
Quaternion& B) const
{
return Quaternion(Re+B.Re, I+B.I, J+B.J, K+B.K);
}
template<typename T> const Quaternion<T>& Quaternion<T>::operator=(const 
Quaternion& B)
{
Re = B.Re;
I = B.I;
J = B.J;
K = B.K;
return B;
}
Ciao e grazie, Aspidus.

 
 
http://www.parashift.com/c++-faq-lite/templates.html#faq-35.12
M

Stavo uscendo pazzo! Grazie Max M. a questo punto deduco che il problema 
non erano i templates, ma era proprio questa cosa che mi hai segnalato tu.
Non potevo definire i metodi e gli overload degli operatori in un file 
.cpp separato come una normale classe. Si imapra sempre qualcosa di 
nuovo :-D
Ovviamente grazie anche ad Enrico
Aspidus
Max M. ha scritto:
