2013-08-16 32 views
5

Abbiamo la seguente classe. Ho bisogno di una spiegazione di alcune parti del codice.Parola chiave dell'operatore C++

class CPoint3D 
    { 
    public: 
     double x, y, z; 

     CPoint3D (double dX = 0.0, double dY = 0.0, double dZ = 0.0) 
       : x(dX), y(dY), z(dZ) {} 
     //what means these lines of code? 
     CPoint3D operator + (const CPoint3D& point) const; 
     CPoint3D operator - (const CPoint3D& point) const; 
     CPoint3D operator * (double dFactor) const; 
     CPoint3D operator/(double dFactor) const; 
}; 

Credo che usando

CPoint3D operator + (const CPoint3D& point) const;

funzione posso facilmente aggiungere/sottrarre casi/moltiplicare/dividere di CPoint3D classe?

Qualcuno può spiegare questo con esempi? Grazie!

+0

Vuoi sapere come utilizzare gli operatori o le modalità di attuazione? – doctorlove

+0

@doctorlove, entrambi. – Nurlan

+1

C'è una [domanda epica] (http://stackoverflow.com/questions/4421706/operator-overloading) che spiega tutto abbastanza bene. – juanchopanza

risposta

10

Ci sono milioni di esempi e/o articoli di questo sul web (incluso this one) quindi non li reiterherò qui.

Basti dire che quando si aggiunge insieme due CPoint3D oggetti con obj1 + obj2, la funzione che viene chiamato è operator+ per quella classe, e un oggetto di essere this e l'altro è point.

Il codice è responsabile della creazione di un altro oggetto contenente l'aggiunta di questi due, quindi restituendolo.

Idem per la sottrazione. Gli operatori moltiplicativi sono leggermente diversi da poiché usano un doppio come argomento - presumibilmente mentre ha un senso aggiungere/sottrarre singoli membri della classe per gli operatori additivi, che non è così utile per quelli moltiplicativi.

3

È possibile leggere alcune pubblicazioni relative a C++ operator overloading. Inoltre here, o here, o semplicemente Google it :)

Ecco un semplice esempio da cplusplus.com:

// vectors: overloading operators example 
#include <iostream> 
using namespace std; 

class CVector { 
    public: 
    int x,y; 
    CVector() {}; 
    CVector (int,int); 
    CVector operator + (CVector); 
}; 

CVector::CVector (int a, int b) { 
    x = a; 
    y = b; 
} 

CVector CVector::operator+ (CVector param) { 
    CVector temp; 
    temp.x = x + param.x; 
    temp.y = y + param.y; 
    return (temp); 
} 

int main() { 
    CVector a (3,1); 
    CVector b (1,2); 
    CVector c; 
    c = a + b; 
    cout << c.x << "," << c.y; 
    return 0; 
} 
+3

Forse prendere costCoint3D e punto per l'operatore + come l'OP? – doctorlove

+0

Bene, i tipi di argomenti degli operatori di non assegnazione sovraccaricati in realtà non hanno alcuna importanza. Non hanno alcun senso! Questo non è come i costruttori di copia/spostamento/operatori di assegnazione, dove l'argomento deve essere uno dei tipi definiti di _valore_ che rappresentano lo stesso tipo in modo da essere considerato una copia/mossa "reale". Ma per qualsiasi oggetto più grande, passare da 'const e' reference sarebbe più efficiente. L'esempio qui, contenente 2 tipi di base, I _think_ si trova proprio al confine, dove sarebbe necessario un accurato benchmarking per dimostrare se passare per copia o -ref è più efficiente. –

+0

Btw, dal momento che l'argomento è di valore, se qualcuno si chiede perché questa risposta non abbia aggiunto e restituito _that_, una buona ragione - che presumo che Didac avesse in mente! - è che gli argomenti sono esenti dall'ottimizzazione del valore di ritorno con nome: http://stackoverflow.com/q/6009278/2757035 Quindi, mentre si potrebbe pensare che sia lenta creare un temporaneo e aggiungerlo ad esso invece - così facendo si abilita il compilatore (forse !) esegue le grandi trasformazioni inerenti a RVO e ottiene un risultato molto più efficiente costruendo 'temp' direttamente sul sito di chiamata, invece di restituire letteralmente un valore che deve essere copiato. –