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;
}

编译时没有警告，输出按预期 ...

类型转换重载

1 个答案: