Newsgroup: it.comp.lang.c++
Titolo: 'operator*' not implemented in type 'Matrice' ...

Salve a tutti,
sto implementanto una classe il cui scopo e'
rappresentare delle matrici. Ho definito un
operator*(Matrice &um), operator=, il costruttore
di copia e un metodo T() che ritorna la trasposta
della matrice per la quale é chiamato.
Sto usando attualmente il compilatore C++Builder
3.0 e il compilatore g++ fornito con i tools
della Cygnus.
Il problema é che se I e D sono istanze della
classe Matrice e in una espressione scrivo:
I=D.T()*D
non ci sono problemi, entrambi i compilatori non
danno nessun errore.
Se invece scrivo
T=D*D.T()
Il compilatore Borland mi dá il seguente errore:
[C++Error] asta.cpp(93): Could not find a match
for 'Matrice::operator =(Matrice)'.
Il g++ un semplice warning:
asta.cpp:96: warning: initialization of non-const
reference `class Matrice &' from rvalue `Matrice'
Il motivo di tutto questo mi sfugge: potete darmi
qualche idea.
Grazie
Gianluigi Platino
Sent via Deja.com 
http://www.deja.com/
Before you buy.

 
Dovresti modificare leggermente operator*() in modo che accetti un const
Matrice & (oppure un semplice Matrice, ma la prima è preferibile).
Presumo infatti che T() restituisca un Matrice e quindi produca un oggetto
temporaneo (rvalue), che non può essere impunemente usato per
inizializzare un reference non-const. Questo per il warning del g++. Non
mi è chiaro invece perchè il Borland dia quell'errore. O meglio, non
capisco perchè lo dia soltanto nel secondo caso. Puoi postare l'esatta
dichiarazione di operator=() ?
Max

 qualche idea.
Avendo dichiarato l'operatore di moltiplicazione
che accetta un non-const reference il compilatore
assume che tu intenda modificare il contenuto del
termine di destra in una moltiplicazione.
Lo standard C++ vieta di passare una variabile
temporanea come reference non-const (si e' pensato
che raramente un programmatore vuole alterare una
variabile che poi viene buttata)
Quando si usa passare dei reference per semplici
motivi prestazionali si dovrebbe sempre
utilizzare 'const' per informare il compilatore
che l'oggetto passato non verra' alterato.
Penso che il comportamento del compilatore
borland sia piu' corretto (non so se pero' lo
standard richiede in effetti solo un messaggio
di diagnostica in questo caso).
HTH
Andrea
----------------------------------------------------------------
 <\___/>  Andrea        email: agriff at tin dot it
 / . . \  "6502"          irc: _6502_@EFNET#italia
(  (")  ) Griffini   homepage: 
http://www.netservers.com/~agriff


 T=D*D.T()
Probabilmente è solo un errore di battitura ma la variabile T alla quale
assegni il risultato cos'è?
EMG

Matrice & (oppure un semplice Matrice, ma la prima è preferibile).
In effetti c'erano una serie di errori da principiante. Principalmente sono 
stato tratto in inganno da questo fatto: avevo definito 
double & operator()(int i=0, int j=0); 
in modo da restituire gli elementi della Matrice e non potevo dichiararlo 
const 
per poter modificare gli elementi stessi. Avevo anche definito un
double & A(int i=0, int j=0);
che faceva le stesse identiche cose.
Il problema stava nel fatto che l'uno o l'altro venivano richiamati sia da 
operator* che da operator= quindi nessun dei due poteva avere argomenti 
const.
Ho risolto problema dichiarando un nuovo metodo 
double V(int i=0, int j=0) const;
da utilizzarsi ogni qualvolta si é sicuri che non si vuole modificare il 
contenuto della matrice. L'operator() e A(int,int) restano per le 
operazioni di 
lettura/scrittura.
Ora entrambi i compilatori digeriscono il codice. La attuale dichiarazione 
di 
operator() é:
Matrice operator=(const Matrice &um);
come da qualunque manuale....
Grazie per l'aiuto.
Saluti,
Gianluigi Platino
____________________________________________________
Per risposte private rimuovere i caratteri maiuscoli
Remove capital letters for private replies