Operator überladen *

Question

Ich habe eine vector3-Klasse, die ich verschiedene Multiplikationsoptionen implementieren muss (so überlastete ich den Operator *) abhängig von den Typen, die multiplizieren.

Das Problem ist, dass in der letzten i den Fehler:

Description Resource Path Location Type 
ambiguating new declaration of 'Pang::vector3 Pang::operator*(const Pang::vector3&, const Pang::vector3&)' vector3.h /PangGame/src line 130  

C/C++ Problem

Aber ich habe nur eine operator überlastet, die vector und muyltiplies zwei vector s zurück.

Hoffe, dass Sie helfen können, ex (nur die Klasse Vektor 3 hat Threee Doppel Zahlen zu klären): vector3(double x, double y, double z);)

friend vector3 operator* (const double& number, const vector3& vector) 
     { 
    vector3 result; 
    result.x = number*vector.x; 
    result.y = number*vector.y; 
    result.z = number*vector.z; 
    return result; 
     } 

friend vector3 operator* (const vector3& vector, const double& number) 
      { 
     vector3 result; 
     result.x = number*vector.x; 
     result.y = number*vector.y; 
     result.z = number*vector.z; 
     return result; 
      } 
//Scalar product: If a = a1i + a2j + a3k and b = b1i + b2j + b3k then 
// a · b = a1*b1 + a2*b2 + a3*b3 
friend double operator* (const vector3& vector1, const vector3& vector2) 
{ 
     double result; 
     result= (vector1.x)*(vector2.x)+(vector1.y)*(vector2.y) + (vector1.z)*(vector2.z); 
     return result; 
} 

/* Product: Vector x Vector 
    * Example: The cross product of a = (2,3,4) and b = (5,6,7) 

cx = aybz - azby = 3×7 - 4×6 = -3 
cy = azbx - axbz = 4×5 - 2×7 = 6 
cz = axby - aybx = 2×6 - 3×5 = -3 
Answer: a × b = (-3,6,-3)*/ 
friend vector3 operator* (const vector3& vector,const vector3& vector2) 
       { 
      vector3 result; 
      result.x = (vector.y)*(vector2.z) - (vector.z)*(vector2.y); 
      result.y = (vector.z)*(vector2.x) - (vector.x)*(vector2.z); 
      result.z = (vector.x)*(vector2.y) - (vector.y)*(vector2.x); 
      return result; 
       } 

Answer 1

Das Problem ist, dass Sie operator* versuchen, auf den Rückgabetyp basiert, um eine Überlastung:

double operator* (const vector3& vector1, const vector3& vector2) 
vector3 operator* (const vector3& vector1, const vector3& vector2) 

Dies ist nicht zulässig, da die Überladungsauflösung berücksichtigt die Funktion Unterschrift, die does not include the return type:

3.19 signature [defns.signature]

⟨function⟩ name, parameter-type-list, and enclosing namespace (if any)

---

Eine mögliche Lösung, wenn Sie Ihre operator* möglicherweise nicht möchten, erhalten entweder ein double oder eine andere vector3, Sie einen Proxy-Typ zurückgeben können, die auf diese Art umwandelbar ist:

struct vector3_multiplication_proxy { 
    vector3 lhs, rhs; 
    operator double() { return 0; /* Your inner product calculation here */ } 
    operator vector3() { return {}; /* Your cross product calculation here */ } 
}; 

vector3_multiplication_proxy operator* (const vector3& lhs, const vector3& rhs) { 
    return {lhs, rhs}; 
} 

Diese hat lebenslange Fallstricke und kann die Berechnung verzögern, je nachdem, wie Sie es verwenden, also ist es vielleicht eine gute Idee. In Ihrem speziellen Fall ist es wahrscheinlich eine schlechte Idee, weil die inneren und Kreuzprodukte unterschiedliche Dinge sind und wahrscheinlich mit unterschiedlicher Syntax bezeichnet werden sollten.