C++ 運算符重載限制深度解析：為什麼 =、->、[]、() 不能重載為友元函數

場景 2：類定義了 operator= 成員函數

class A {
    // ... 同上 ...
    A& operator=(int xx) {  // 成員函數
        cout << "Call A::operator=(int)" << endl;
        x = xx;
        return *this;
    }
};

int main() {
    A a;
    a = 7;  // 現在輸出什麼？
}

輸出: Call A::operator=(int)

結論：成員函數優先於隱式轉換+默認賦值。一旦定義了成員 operator=，編譯器不再考慮轉換構造函數路徑。

為什麼不能是友元函數？

假設允許 friend A& operator=(A&, int) 作為友元：

1. 類 A 內部沒有成員 operator=。
2. 全局/友元作用域有 operator=(A&, int)。
3. 執行 a = 7 時，編譯器面臨二義性：
   • 路徑 A：按無成員 operator= 處理 → 調用轉換構造函數 A(7) → 默認拷貝賦值。
   • 路徑 B：匹配全局友元 operator=(a, 7)。
4. C++ 拒絕二義性，直接報錯。

同理：operator->、operator[]、operator() 都有編譯器隱式生成的默認行為 (如指針解引用、下標訪問、函數調用)，允許友元重載會產生相同的二義性衝突。

四大運算符的特殊語義

正確重載模式示例

賦值運算符 (複製與移動)

class String {
    char* data;
    size_t len;
public:
    // 複製賦值
    String& operator=(const String& other) {
        if (this != &other) { // 自賦值檢查
            delete[] data;
            len = other.len;
            data = new char[len + 1];
            memcpy(data, other.data, len + 1);
        }
        return *this;
    }
    // 移動賦值 (C++11)
    String& operator=(String&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            len = other.len;
            other.data = nullptr;
            other.len = 0;
        }
        return *this;
    }
};

下標運算符 (const/非 const 重載)

class Vector {
    double* elem;
    int sz;
public:
    // 非 const 版本: 支持 v[i] = 3.14 (左值)
    double& operator[](int i) { 
        if (i < 0 || i >= sz) throw out_of_range("Vector::operator[]");
        return elem[i]; 
    }
    // const 版本: 支持 const Vector cv; cv[i] (右值)
    double operator[](int i) const { 
        if (i < 0 || i >= sz) throw out_of_range("Vector::operator[] const");
        return elem[i]; 
    }
};

函數調用運算符 (函數對象/仿函數)

struct Adder {
    int base;
    Adder(int b) : base(b) {}
    // 使對象可調用: adder(5) 相當於 adder.operator()(5)
    int operator()(int x) const { return base + x; }
};

int main() {
    Adder add10(10);
    cout << add10(5) << endl; // 15 - 像函數一樣調用對象
    // STL 算法大量使用: sort(v.begin(), v.end(), [](a,b){return a>b;});
}

箭頭運算符 (智能指針核心)

template
class UniquePtr {
    T* ptr;
public:
    UniquePtr(T* p = nullptr) : ptr(p) {}
    ~UniquePtr() { delete ptr; }
    
    // 關鍵: 返回指針，支持鏈式 -> 操作
    T* operator->() const { 
        if (!ptr) throw runtime_error("Dereference null");
        return ptr; 
    }
    T& operator*() const { return *ptr; }
};

struct Foo { void bar() { cout << "Foo::bar()" << endl; } };

int main() {
    UniquePtr p(new Foo());
    p->bar(); // 編譯器展開為: p.operator->()->bar()
              // 即: (p.operator->())->bar()
}

總結

C++ 強制 operator=、operator->、operator[]、operator() 為非靜態成員函數，根本原因是：

1. 消除二義性：避免與編譯器隱式生成的默認行為 (轉換構造+默認賦值、指針解引用等) 衝突。
2. 語義綁定：這些運算符本質上操作對象自身狀態，需要 this 指針訪問私有成員、保證鏈式調用正確性、支持左值語義。
3. 封裝性：作為成員函數自然訪問 private/protected 成員，無需破壞封裝聲明友元。

理解這一設計哲理，有助於在設計自定義類型時正確實現值語義、智能指針、容器、函數對象等核心 C++ 抽象機制。