不同的编译器调用不同的cast运算符 考虑下面的C++程序： #include <iostream> class B { public: operator bool() const { return false; } }; class B2 : public B { public: operator int() { return 5; } }; int main() { B2 b; std::cout << std::boolalpha << (bool)b << std::endl; } #包括 B类{ 公众： 运算符bool（）常量{ 返回false； } }; B2类：公共B类{ 公众： 运算符int（）{ 返回5； } }; int main（）{ b2b； St::CUT< P> C++的布尔类型有两个值，即真值和假值，对应值1和0。如果在B2类中添加布尔运算符，则可以避免固有的混淆，这类调用显式地调用基类（B）的布尔运算，输出为假。 这是我修改过的程序，运算符bool表示运算符bool，而不是int #include <iostream> class B { public: operator bool() const { return false; } }; class B2 : public B { public: operator int() { return 5; } operator bool() { return B::operator bool(); } }; int main() { B2 b; std::cout << std::boolalpha << (bool)b << std::endl; } #包括 B类{ 公众： 运算符bool（）常量{ 返回false； } }; B2类：公共B类{ 公众： 运算符int（）{ 返回5； } 运算符bool（）{ 返回B：：运算符bool（）； } }; int main（）{ b2b； 标准规定：

派生类中的转换函数不会隐藏基类中的转换函数，除非这两个函数转换为同一类型

§12.3[类别转换]

这意味着

运算符bool

不会被

运算符int

隐藏

该标准规定：

在重载解析期间，隐含对象参数与其他参数无法区分

§13.3.3.1[超过匹配功能]

这种情况下的“隐含对象参数”是

b

，它的类型是

B2&

运算符bool需要

常量B2&

，因此编译器必须将常量添加到

b

以调用

运算符bool

。这——所有其他条件都相同——使得

运算符int

更匹配

该标准规定，如果满足以下条件，则

静态\u转换

（在本例中C样式转换正在执行）可以转换为类型

T

（在本例中为

int

）：

对于一些发明的临时变量

T

，声明

T（e）；

格式良好

§5.2.9[解释静态铸造]

因此，

int

可以转换为

bool

，而

bool

同样可以转换为

bool

该标准规定：

考虑了

S

的转换函数及其基类。那些不隐藏在

S

中的非显式转换函数和产生类型

T

或可通过标准转换序列转换为类型

T

的类型都是候选函数

§13.3.1.5[超过匹配转换]

因此，重载集由

运算符int

和

运算符bool

组成。在所有其他条件相同的情况下，

运算符int

是更好的匹配（因为不必添加常量）。因此，应选择

运算符int

注意到（也许违反直觉）标准一旦被添加到重载集合（如上所述），就不考虑返回类型（即这些运算符转换的类型），只要其中一个参数的转换序列优于另一个参数的转换序列。（由于康斯特内斯的原因，本例就是如此）

该标准规定：

给定这些定义，如果对于所有参数i，ICSi（F1）不是比ICSi（F2）更差的转换序列，则可行函数F1被定义为比另一个可行函数F2更好的函数，然后

• 对于某些参数j，ICSj（F1）是比ICSj（F2）更好的转换序列，或者，如果不是这样
• 上下文是通过用户定义的转换进行的初始化，从返回类型F1到目标类型（即被初始化的实体类型）的标准转换序列比从返回类型F2到目标类型的标准转换序列更好

§13.3.3[超过匹配最佳值]

在这种情况下，只有一个参数（隐式的

this

参数）。

B2&

=>

B2&

（调用

运算符int

）的转换顺序优于

B2&

常量B2&（调用

运算符bool

），因此从重载集中选择

运算符int

，而不考虑它实际上不会直接转换为

bool

Short 转换函数

operator int（）

是通过在

operator bool（）const

上敲打来选择的，因为

b

不是const限定的，而bool的转换运算符是

简单的理由是，当将

b

转换为

bool

时，重载解析的候选函数（隐式对象参数已就位）是

operator bool (B2 const &);
operator int (B2 &);

其中第二个匹配更好，因为

b

不符合常量

如果两个函数共享相同的限定条件（无论是否都

const

），则选择

运算符bool

，因为它提供直接转换

通过强制转换表示法进行转换，逐步分析

---

如果我们同意布尔型ostream插入器（std:：basic_ostream:：operator前面的一些答案，那么它已经提供了很多信息

我的贡献是，“cast操作”的编译与“重载操作”类似，我建议为每个操作创建一个具有唯一标识符的函数，然后用所需的运算符或cast替换它

#include <iostream>

class B {
public:
    bool ToBool() const {
        return false;
    }
};

class B2 : public B {
public:
    int ToInt() {
        return 5;
    }
};

int main() {
    B2 b;
    std::cout << std::boolalpha << b.ToBool() << std::endl;
}

#include <iostream>

class B {
public:
    operator bool() {
        return false;
    }
};

class B2 : public B {
public:
    operator int() {
        return 5;
    }
};

int main() {
    B2 b;
    std::cout << std::boolalpha << (bool)b << std::endl;
}

#包括
B类{
公众：
bool ToBool（）常量{
返回false；
}
};
B2类：公共B类{
公众：
int-ToInt（）{
返回5；
}
};
int main（）{
b2b；
std:：cout据我所知，B2有两个运算符：B:：运算符bool（）和B2:：运算符int（）。这两个运算符都不是常量运算符，并且常量和非常量版本之间存在差异
operator bool (B2 const &);
operator int (B2 &);

#include <iostream>

class B {
public:
    bool ToBool() const {
        return false;
    }
};

class B2 : public B {
public:
    int ToInt() {
        return 5;
    }
};

int main() {
    B2 b;
    std::cout << std::boolalpha << b.ToBool() << std::endl;
}

#include <iostream>

class B {
public:
    operator bool() {
        return false;
    }
};

class B2 : public B {
public:
    operator int() {
        return 5;
    }
};

int main() {
    B2 b;
    std::cout << std::boolalpha << (bool)b << std::endl;
}