類型重載

Question

我需要拋出一個異常，當我做這樣的類型轉換時：(B*)a其中a是指向基類A的對象的指針，B是派生類。

class A 
{ 
    protected: 
     int a; 
    public: 
     operator B*() 
     { 
      throw(1); 
     } 

}; 

class B: public A 
{ 
protected: 
    int b; 
}; 

void main() 
{ 
    A *a; 
    (B*)a; 
} 

我嘗試重載，但它不適用於指向A的指針，只能用於對象。如何重載這個操作來使它與指向我的基類的指針一起工作？

Answer 1

您只能爲類提供自定義轉換器，而不是指針。但是你可以創建一個模仿指針的類（這就是智能指針的工作方式）。

這裏有這樣一類的例子：

#include <iostream> 

class A 
{ 
protected: 
    int a; 
public: 
    int getA() { 
     return a; 
    } 
    virtual ~A() {} // intended to be derived 
}; 

class B; // forward declaration 

class Astar { // mimics a A* 
private: 
    A* pa; 
public: 
    Astar(A* p): pa(p) {} 
    A* operator ->() { 
     return pa; 
    } 
    operator B*(); // declare the custom conversion operator 
    A& operator *() { 
     return *pa; 
    } 
}; 

class B: public A 
{ 
protected: 
    int b; 
public: 
    B(int a, int b): b(b) { 
     A::a = a; 
    } 
    int getB() { 
     return b; 
    } 
}; 

Astar::operator B*() {   // defines the custom conversion 
    return dynamic_cast<B *>(pa); 
} 

int main() 
{ 
    B b(1,2); 
    Astar x(&b);  // x acts exactly as a A* would: 
    std::cout << x->getA() << " - " << (*x).getA() << std::endl; 

    B* pb = x;   // conversion to a plain B* is automatic 
    std::cout << pb->getB() << std::endl; 
    return 0; 
} 

編譯沒有警告，並輸出預期 ...