Visualizzazione dei risultati da 1 a 7 su 7
  1. #1

    [C++] Operator Overloading su Template

    Ho un problema su questa classe template:

    codice:
    template <class T>  Mat<T>& Mat<T>::operator+(Mat& Matsomma) { 	
    
    risultato = new Mat<T>(row,col);  
    
     		for(int i=0; i < row ; i++){ 		
    	             for(int j=0; j < col; j++){ 				
                                risultato.mat[i][j] = mat[i][j] + Matsomma.mat[i][j]; 		
    } } }
                return *risultato; 
    }
    ho già dichiarato il puntatore a "risultato"
    codice:
       Mat<T>* risultato;

    Mi da questo errore:
    request for member 'mat' in '((Mat<int>*)this) -> Mat<int>::risultato' , which is of pointer type...


    Come posso risolvere questo problema, senza sprechi di memoria inutili dichiarando una matrice per i risultati... che in altri metodi potrebbe rimanere inutilizzate o riscrivendo il risultato sulla matrice principale?

    Grazie

  2. #2
    Probabilmente intendevi
    codice:
                                risultato->mat[i][j] = mat[i][j] + Matsomma.mat[i][j];
    Comunque mi lascia perplesso il fatto che restituisci tramite reference un oggetto allocato con new, mi sembra un'ottima ricetta per avere memory leaks...
    Amaro C++, il gusto pieno dell'undefined behavior.

  3. #3
    Originariamente inviato da MItaly
    Probabilmente intendevi
    codice:
                                risultato->mat[i][j] = mat[i][j] + Matsomma.mat[i][j];
    Comunque mi lascia perplesso il fatto che restituisci tramite reference un oggetto allocato con new, mi sembra un'ottima ricetta per avere memory leaks...
    Eh no io vorrei avere praticamente avere una matrice allocata su memoria dinamica (risultato) la quale mi contiene le matrici sommate, come mi hai scritto mi modifica la matrice principale (mat)


  4. #4
    No, risultato->mat si riferisce al mat membro dell'istanza a cui fa riferimento risultato (che è quella che hai allocato dinamicamente), non al mat dell'oggetto corrente.

    Ribadisco comunque che è una pessima idea fare overloading degli operatori in questa maniera, visto che gli operatori così ridefiniti sono inutilizzabili; supponi di voler sommare tre matrici:

    codice:
    Mat<int> m1, m2, m3;
    
    // ... qui vengono inizializzate in qualche maniera ...
    
    Mat<int> ris;
    ris = m1 + m2 + m3;
    Con la tua implementazione di operator+, in questo codice apparentemente innocente si nascondono tre memory leaks, dato che tutti gli oggetti temporanei creati dalle chiamate a operator+ sono allocati dinamicamente ma non vengono mai deallocati tramite delete.

    Infine, di rado si effettua l'overloading dell'operatore + in quella maniera, piuttosto si fa l'overloading di += e in base a quello (e al costruttore di copie) si definisce operator+.
    Amaro C++, il gusto pieno dell'undefined behavior.

  5. #5
    Originariamente inviato da MItaly
    No, risultato->mat si riferisce al mat membro dell'istanza a cui fa riferimento risultato (che è quella che hai allocato dinamicamente), non al mat dell'oggetto corrente.

    Ribadisco comunque che è una pessima idea fare overloading degli operatori in questa maniera, visto che gli operatori così ridefiniti sono inutilizzabili; supponi di voler sommare tre matrici:

    codice:
    Mat<int> m1, m2, m3;
    
    // ... qui vengono inizializzate in qualche maniera ...
    
    Mat<int> ris;
    ris = m1 + m2 + m3;
    Con la tua implementazione di operator+, in questo codice apparentemente innocente si nascondono tre memory leaks, dato che tutti gli oggetti temporanei creati dalle chiamate a operator+ sono allocati dinamicamente ma non vengono mai deallocati tramite delete.

    Infine, di rado si effettua l'overloading dell'operatore + in quella maniera, piuttosto si fa l'overloading di += e in base a quello (e al costruttore di copie) si definisce operator+.
    ora funziona con il -> .... però non ho capito bene perchè si mette -> e non il . , se puoi spiegarmelo brevemente ti ringrazio

  6. #6
    Originariamente inviato da Fixxxer393
    ora funziona con il -> .... però non ho capito bene perchè si mette -> e non il . , se puoi spiegarmelo brevemente ti ringrazio
    Perché risultato è un puntatore, non un oggetto. L'equivalente con il punto sarebbe (*risultato).mat, dove l'asterisco derererenzia il puntatore, e con il punto accedi al membro.

    Ribadisco comunque tutto il resto: una classe con gli operatori scritti in questa maniera è inutilizzabile.
    Amaro C++, il gusto pieno dell'undefined behavior.

  7. #7
    Originariamente inviato da MItaly
    Perché risultato è un puntatore, non un oggetto. L'equivalente con il punto sarebbe (*risultato).mat, dove l'asterisco derererenzia il puntatore, e con il punto accedi al membro.

    Ribadisco comunque tutto il resto: una classe con gli operatori scritti in questa maniera è inutilizzabile.
    oook grazie mille...

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.