C++ 在c+中重写强制转换操作+；

在下面给出的代码中，当使用参数d（派生类型）调用func方法时，它将转换为基&。我想知道是否可以覆盖此强制转换操作。当我的程序中发生这种特殊的强制转换时，我想调用一些操作。可能吗

class base{};

class derived : public base{
    int a;
};

int func(base &a){
    printf("Conversion from derived to base&", &a);
}

int main(){
    derived d;
    func(d);
}

---

派生到基的转换不是强制转换

强制转换是表示转换的符号

---

如果希望函数只接受特定类型的参数，则可以将其设置为模板，并使用SFINAE，如

std:：enable\u if

。除此之外（这并不总是适用），一般来说，您不能禁止派生到基。但是您可以删除派生类关系

派生到基的转换不是强制转换

强制转换是表示转换的符号

---

如果希望函数只接受特定类型的参数，则可以将其设置为模板，并使用SFINAE，如

std:：enable\u if

。除此之外（这并不总是适用），一般来说，您不能禁止派生到基。但是您可以删除派生类关系

可以为派生类提供func重载，如下所示：

#include <cstdio>

class base{};

class derived : public base{
    int a;
};

int func(base &a){
    printf("Conversion from derived to base&\n");
    return 0;
}

int func(derived &a){
    printf("called with derived&\n");

    // defer to the base version if you wish
    return func(static_cast<base&>(a));
}

int main(){
    derived d;
    func(d);
}

#包括
类基{}；
派生类：公共基{
INTA；
};
int func（基&a）{
printf（“从派生到基的转换&\n”）；
返回0；
}
int func（派生&a）{
printf（“使用派生的&\n调用”）；
//如果您愿意，请遵循基本版本
返回函数（静态_cast（a））；
}
int main（）{
导出d；
func（d）；
}

但它的风格低劣且脆弱（当有人定义它们时，它不适用于derived2或derived3）

一种更为正确的（即：可维护、优雅，并且可能防止同事讨厌您）样式是将不同的操作封装在基本/派生层次结构中的虚拟方法中。然后自由函数（作用于base&）服从于base的接口，并允许派生类自行处理：

#include <cstdio>

class base{
public:
    int func() {
        return handle_func();
    }

protected:
    virtual int handle_func() {
        printf("base&\n");
        return 0;
    }
};

class derived : public base{
    int a;

private:
    virtual int handle_func() override {
        printf("derived&\n");
        return base::handle_func();
    }

};

int func(base &a){
    return a.func();
}

int main(){
    derived d;
    func(d);
}

#包括
阶级基础{
公众：
int func（）{
返回句柄_func（）；
}
受保护的：
虚整数句柄_func（）{
printf（“基础和\n”）；
返回0；
}
};
派生类：公共基{
INTA；
私人：
虚int句柄函数（）重写{
printf（“派生的&\n”）；
return base:：handle_func（）；
}
};
int func（基&a）{
返回a.func（）；
}
int main（）{
导出d；
func（d）；
}

您可以为派生类提供func重载，如下所示：

#include <cstdio>

class base{};

class derived : public base{
    int a;
};

int func(base &a){
    printf("Conversion from derived to base&\n");
    return 0;
}

int func(derived &a){
    printf("called with derived&\n");

    // defer to the base version if you wish
    return func(static_cast<base&>(a));
}

int main(){
    derived d;
    func(d);
}

#包括
类基{}；
派生类：公共基{
INTA；
};
int func（基&a）{
printf（“从派生到基的转换&\n”）；
返回0；
}
int func（派生&a）{
printf（“使用派生的&\n调用”）；
//如果您愿意，请遵循基本版本
返回函数（静态_cast（a））；
}
int main（）{
导出d；
func（d）；
}

但它的风格低劣且脆弱（当有人定义它们时，它不适用于derived2或derived3）

一种更为正确的（即：可维护、优雅，并且可能防止同事讨厌您）样式是将不同的操作封装在基本/派生层次结构中的虚拟方法中。然后自由函数（作用于base&）服从于base的接口，并允许派生类自行处理：

#include <cstdio>

class base{
public:
    int func() {
        return handle_func();
    }

protected:
    virtual int handle_func() {
        printf("base&\n");
        return 0;
    }
};

class derived : public base{
    int a;

private:
    virtual int handle_func() override {
        printf("derived&\n");
        return base::handle_func();
    }

};

int func(base &a){
    return a.func();
}

int main(){
    derived d;
    func(d);
}

#包括
阶级基础{
公众：
int func（）{
返回句柄_func（）；
}
受保护的：
虚整数句柄_func（）{
printf（“基础和\n”）；
返回0；
}
};
派生类：公共基{
INTA；
私人：
虚int句柄函数（）重写{
printf（“派生的&\n”）；
return base:：handle_func（）；
}
};
int func（基&a）{
返回a.func（）；
}
int main（）{
导出d；
func（d）；
}

如果此隐式转换（强制转换是显式转换）出现问题，则您的类层次结构很可能不是一个好主意，需要重新思考。如果此隐式转换（强制转换是显式转换）出现问题，则您的类层次结构很可能不是一个好主意，需要重新思考。