運營商內部vs外部重載

Question

內部和外部類重載有什麼區別？

class A{ 
    public: 
     bool operator==(const A *i){ 
     .... 
     .... 
     } 
}; 

VS

bool operator==(const A *i , const A *j){ 
    .... 
    .... 
} 

Answer 1

首先使用類考慮這個例子（重新格式化爲一個風格我喜歡）：

class A 
{ 
public: 
    auto operator==(A const* p) 
     -> bool 
    { 
     return true;  // Whatever. 
    } 
}; 

auto main() 
    -> int 
{ 
    A u{}, v{}; 
    A const c{}; 

    bool const r1 = (u == &v); // OK but needlessly annoying. 
    bool const r2 = (c == &v); // !Will not compile. 
} 

這裏

• 由於參數是一個指針，客戶端代碼必須適用&。
• 由於該方法不是const，因此無法比較const的對象。因此

的傳統方法來做到這一點是通過引用傳遞的參數，以使該方法const：

class B 
{ 
public: 
    auto operator==(B const& o) const 
     -> bool 
    { 
     return true;  // Whatever. 
    } 
}; 

auto main() 
    -> int 
{ 
    B u{}, v{}; 
    B const c{}; 

    bool const r1 = (u == v); // OK. 
    bool const r2 = (c == v); // OK. 
} 

如果定義類以外的比較，這樣的：

class B 
{}; 

auto operator==(B const& u, B const& v) 
    -> bool 
{ 
    return true;  // Whatever. 
} 

auto main() 
    -> int 
{ 
    B u{}, v{}; 
    B const c{}; 

    bool const r1 = (u == v); // OK. 
    bool const r2 = (c == v); // OK. 
} 

＆hellip;那麼

• 保證的定義不取決於B類的內部實現細節，這在將來可能會改變。
• 此外，第一個參數可以是一個隱式轉換爲B的值。
• 可以，如果你想，有不同的類型，其中類只出現在第二個參數的形式參數，如下所示：

auto operator==(int const u, B const& v) 
    -> bool 
{ 
    return true;  // Whatever. 
} 

如果您選擇將這些非成員運算符通過friend機制（通過ADL查找找到它們）內聯在類定義中，然後失去了第一個bullet點的優勢，但是在類定義內部，所有代碼都與該類的使用相關：

class B 
{ 
public: 
    friend 
    auto operator==(B const& u, B const& v) 
     -> bool 
    { 
     return true;  // Whatever. 
    } 

    friend 
    auto operator==(int const u, B const& v) 
     -> bool 
    { 
     return true;  // Whatever. 
    } 
}; 

auto main() 
    -> int 
{ 
    B u{}, v{}; 
    B const c{}; 

    bool const r1 = (u == v); // OK. 
    bool const r2 = (c == v); // OK. 
    bool const r3 = (42 == v); // OK. 
}